Mac OS X was released in March 2001, but many components, such as Mach and BSD, are considerably older. Understanding the design, implementation, and workings of Mac OS X requires examination of several technologies that differ in their age, origins, philosophies, and roles. Mac OS X Internals: A Systems Approach is the first book that dissects the internals of the system, presenting a detailed picture that grows incrementally as you read. For example, you will learn the roles of the firmware, the bootloader, the Mach and BSD kernel components (including the process, virtual memory, IPC, and file system layers), the object-oriented I/O Kit driver framework, user libraries, and other core pieces of software. You will learn how these pieces connect and work internally, where they originated, and how they evolved. The book also covers several key areas of the Intel-based Macintosh computers. A solid understanding of system internals is immensely useful in design, development, and debugging for programmers of various skill levels. System programmers can use the book as a reference and to construct a better picture of how the core system works. Application programmers can gain a deeper understanding of how their applications interact with the system. System administrators and power users can use the book to harness the power of the rich environment offered by Mac OS X. Finally, members of the Windows, Linux, BSD, and other Unix communities will find the book valuable in comparing and contrasting Mac OS X with their respective systems. Mac OS X Internals focuses on the technical aspects of OS X and is so full of extremely useful information and programming examples that it will definitely become a mandatory tool for every Mac OS X programmer.

Linux From Scratch describes the process of creating your own Linux system from scratch from an already installed Linux distribution, using nothing but the source code of software that you need.
From the author's introduction: "Having used a number of different Linux distributions, I was never fully satisfied with either of those. I didn't like the way the bootscripts were arranged, or I didn't like the way certain programs were configured by default and more of those things. I came to realize that when I want to be totally satisfied with a Linux system, I have to build my own Linux system from scratch. Ideally only using the source code. No pre-compiled packages of any kind. No help from some sort of cdrom or bootdisk that would install some basic utilities. You would use your current Linux system and use that one to build your own.
This, at one time, wild idea seemed very difficult and at times almost impossible. The reason for most problems were due to my lack of knowledge about certain programs and procedures. After I sorted out all kinds of dependency problems, compilation problems, etcetera, a manually Linux system was created and fully operational. I called this system and LFS system which stands for Linux From Scratch."

Want to tap the power behind search rankings, product recommendations, social bookmarking, and online matchmaking? This fascinating book demonstrates how you can build Web 2.0 applications to mine the enormous amount of data created by people on the Internet. With the sophisticated algorithms in this book, you can write smart programs to access interesting datasets from other web sites, collect data from users of your own applications, and analyze and understand the data once you've found it. Programming Collective Intelligence takes you into the world of machine learning and statistics, and explains how to draw conclusions about user experience, marketing, personal tastes, and human behavior in general -- all from information that you and others collect every day. Each algorithm is described clearly and concisely with code that can immediately be used on your web site, blog, Wiki, or specialized application. This book explains: * Collaborative filtering techniques that enable online retailers to recommend products or media * Methods of clustering to detect groups of similar items in a large dataset * Search engine features -- crawlers, indexers, query engines, and the PageRank algorithm * Optimization algorithms that search millions of possible solutions to a problem and choose the best one * Bayesian filtering, used in spam filters for classifying documents based on word types and other features * Using decision trees not only to make predictions, but to model the way decisions are made * Predicting numerical values rather than classifications to build price models * Support vector machines to match people in online dating sites * Non-negative matrix factorization to find the independent features in a dataset * Evolving intelligence for problem solving -- how a computer develops its skill by improving its own code the more it plays a game Each chapter includes exercises for extending the algorithms to make them more powerful. Go beyond simple database-backed applications and put the wealth of Internet data to work for you. "Bravo! I cannot think of a better way for a developer to first learn these algorithms and methods, nor can I think of a better way for me (an old AI dog) to reinvigorate my knowledge of the details." -- Dan Russell, Google "Toby's book does a great job of breaking down the complex subject matter of machine-learning algorithms into practical, easy-to-understand examples that can be directly applied to analysis of social interaction across the Web today. If I had this book two years ago, it would have saved precious time going down some fruitless paths." -- Tim Wolters, CTO, Collective Intellect

Structure and Interpretation of Computer Programs has had a dramatic impact on computer science curricula over the past decade. This long-awaited revision contains changes throughout the text.
There are new implementations of most of the major programming systems in the book, including the interpreters and compilers, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published.
A new theme has been introduced that emphasizes the central role played by different approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming and lazy evaluation, and nondeterministic programming. There are new example sections on higher-order procedures in graphics and on applications of stream processing in numerical programming, and many new exercises.
In addition, all the programs have been reworked to run in any Scheme implementation that adheres to the IEEE standard.

本书是被誉为UNIX编程“圣经”的Advanced Programming in the UNIX Environment一书的更新版。在本书第一版出版后的十几年中，UNIX行业已经有了巨大的变化，特别是影响UNIX编程接口的有关标准变化很大。本书在保持了前一版的风格的基础上，根据最新的标准对内容进行了修订和增补，反映了最新的技术发展。书中除了介绍UNIX文件和目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容，还在此基础上介绍了多个应用示例，包括如何创建数据库函数库以及如何与网络打印机通信等。此外还在附录中给出了函数原型和部分习题的答案。
本书内容权威，概念清晰，阐述精辟，对于所有层次UNIX程序员都是一本不可或缺的参考书。

More than 150,000 copies in print! Praise for Scott Meyers' first book, Effective C++: "I heartily recommend Effective C++ to anyone who aspires to mastery of C++ at the intermediate level or above." - The C/C++ User's Journal From the author of the indispensable Effective C++, here are 35 new ways to improve your programs and designs. Drawing on years of experience, Meyers explains how to write software that is more effective: more efficient, more robust, more consistent, more portable, and more reusable. In short, how to write C++ software that's just plain better. More Effective C++ includes: * Proven methods for improving program efficiency, including incisive examinations of the time/space costs of C++ language features * Comprehensive descriptions of advanced techniques used by C++ experts, including placement new, virtual constructors, smart pointers, reference counting, proxy classes, and double-dispatching * Examples of the profound impact of exception handling on the structure and behavior of C++ classes and functions * Practical treatments of new language features, including bool, mutable, explicit, namespaces, member templates, the Standard Template Library, and more. If your compilers don't yet support these features, Meyers shows you how to get the job done without them. More Effective C++ is filled with pragmatic, down-to-earth advice you'll use every day. Like Effective C++ before it, More Effective C++ is essential reading for anyone working with C++.

GNU Emacs is the most popular and widespread of the Emacs family of editors. It is also the most powerful and flexible. Unlike all other text editors, GNU Emacs is a complete working environment--you can stay within Emacs all day without leaving. Learning GNU Emacs, 3rd Edition tells readers how to get started with the GNU Emacs editor. It is a thorough guide that will also "grow" with you: as you become more proficient, this book will help you learn how to use Emacs more effectively. It takes you from basic Emacs usage (simple text editing) to moderately complicated customization and programming. The third edition of Learning GNU Emacs describes Emacs 21.3 from the ground up, including new user interface features such as an icon-based toolbar and an interactive interface to Emacs customization. A new chapter details how to install and run Emacs on Mac OS X, Windows, and Linux, including tips for using Emacs effectively on those platforms. Learning GNU Emacs, third edition, covers: * How to edit files with Emacs * Using the operating system shell through Emacs * How to use multiple buffers, windows, and frames * Customizing Emacs interactively and through startup files * Writing macros to circumvent repetitious tasks * Emacs as a programming environment for Java, C++, and Perl, among others * Using Emacs as an integrated development environment (IDE) * Integrating Emacs with CVS, Subversion and other change control systems for projects with multiple developers * Writing HTML, XHTML, and XML with Emacs * The basics of Emacs Lisp The book is aimed at new Emacs users, whether or not they are programmers. Also useful for readers switching from other Emacs implementations to GNU Emacs.

手册开门见山，以英语关联词和常用词为引子，综合地讨论它们多种语法功能和搭配用法，使读者通过大量实例扎实地理解和掌握。
对于过去大多数只能死记硬背的“动词+副词或介词+……”的短语改为按英语思维形象化地理解。书中均以动词短语中的介词或副词为引子，通过细致分类汇总了它们和有关动词搭配时的动词短语用法。例如，书中仅副词out的功能性用法分类就有10多种，并且各有许多举例汇总，于是形成形象和联想，语感油然而生。
书中还将编者获奖的“英语前置定语的新发展——夹带介词短语的名词性词组作前置定语”介绍给读者，使记者开阔思路。
这部手册可供大学、中学师生阅读英语材料和学习英语时参考，也可供大学生参加四、六级英语考试，参加研究生入学考试或托福考试前参考学习；还可供广大英语爱好者自学参考。

Product Description
Web technology has become the foundation for all sorts of critical networked applications and far-reaching methods of data exchange, and beneath it all is a fundamental protocol: HyperText Transfer Protocol, or HTTP. HTTP: The Definitive Guide documents everything that technical people need for using HTTP efficiently-including the "black arts" and "tricks of the trade"-and does so in a clear and readable manner. Written by experts with years of practical and teaching experience, this book is the definitive technical bible on HTTP and related core web technologies because it clearly explains the "why" as well as the "how". A reader can understand how web applications work, how the core Internet protocols and architectural building blocks interact, and how to correctly implement Internet clients and servers. It's an essential toolkit that no technically-inclined member of the Internet community should be without.

“Every C++ professional needs a copy of Effective C++ . It is an absolute must-read for anyone thinking of doing serious C++ development. If you’ve never read Effective C++ and you think you know everything about C++, think again.”
— Steve Schirripa, Software Engineer, Google “C++ and the C++ community have grown up in the last fifteen years, and the third edition of Effective C++ reflects this. The clear and precise style of the book is evidence of Scott’s deep insight and distinctive ability to impart knowledge.”
— Gerhard Kreuzer, Research and Development Engineer, Siemens AG The first two editions of Effective C++ were embraced by hundreds of thousands of programmers worldwide. The reason is clear: Scott Meyers’ practical approach to C++ describes the rules of thumb used by the experts — the things they almost always do or almost always avoid doing — to produce clear, correct, efficient code. The book is organized around 55 specific guidelines, each of which describes a way to write better C++. Each is backed by concrete examples. For this third edition, more than half the content is new, including added chapters on managing resources and using templates. Topics from the second edition have been extensively revised to reflect modern design considerations, including exceptions, design patterns, and multithreading. Important features of Effective C++ include: Expert guidance on the design of effective classes, functions, templates, and inheritance hierarchies. Applications of new “TR1” standard library functionality, along with comparisons to existing standard library components. Insights into differences between C++ and other languages (e.g., Java, C#, C) that help developers from those languages assimilate “the C++ way” of doing things.

The Microsoft(R) .NET Framework allows developers to quickly build robust, secure ASP.NET Web Forms and XML Web service applications, Windows(R) Forms applications, tools, and types. Find out all about its common language runtime and learn how to leverage its power to build, package, and deploy any kind of application or component. APPLIED MICROSOFT .NET FRAMEWORK PROGRAMMING is ideal for anyone who understands object-oriented programming concepts such as data abstraction, inheritance, and polymorphism. The book carefully explains the extensible type system of the .NET Framework, examines how the runtime manages the behavior of types, and explores how an application manipulates types. While focusing on C#, it presents concepts applicable to all programming languages that target the .NET Framework. Topics covered include: . The .NET Framework architecture . Building, packaging, deploying, and administering applications and their types . Building and deploying shared assemblies . Type fundamentals . Primitive, reference, and value types . Operations common to all objects . Type members and accessibility . Constants, fields, methods, properties, and events . Working with text . Enumerated types and bit flags . Array types . Interfaces . Custom attributes . Delegates . Error handling with exceptions . Automatic memory management . AppDomains and reflectionIncludes coverage of C#

Git is the version control system developed by Linus Torvalds for Linux kernel development. It took the open source world by storm since its inception in 2005, and is used by small development shops and giants like Google, Red Hat, and IBM, and of course many open source projects.
* A book by Git experts to turn you into a Git expert
* Introduces the world of distributed version control
* Shows how to build a Git development workflow
What you’ll learn
* Use Git as a programmer or a project leader.
* Become a fluent Git user.
* Use distributed features of Git to the full.
* Acquire the ability to insert Git in the development workflow.
* Migrate programming projects from other SCMs to Git.
* Learn how to extend Git.
This book is for all open source developers: you are bound to encounter it somewhere in the course of your working life. Proprietary software developers will appreciate Git’s enormous scalability, since it is used for the Linux project, which comprises thousands of developers and testers.

Part I – Overview
Part I introduces the reader to the basic concepts required to efficiently debug .NET applications using the Debugging Tools for Windows package.
1. Introduction to the Tools
This chapter contains a brief introduction to the tools used throughout the book, including basic usage scenarios, download locations, and installation instructions. Amongst the tools covered are:
Debugging Tools for Windows
.NET 2.0 redist/SDK
SOS
SOSEX
CLR Profiler
Performance Counters
Reflector for .NET
PowerDBG
Managed Debugging Assistants
2. CLR Fundamentals
This chapter discusses the core fundamentals of the CLR. The chapter begins with a high level overview of the major runtime components and subsequently drills down into the details and covers topics such as:
· CLR and the Windows Loader. Discusses how .NET applications are natively supported using the PE file format.
· Application domains (system, shared, default, custom) as well as loader heaps etc.
· Assembly overview
· Assembly manifest
· Type metadata
· And more…
3. Basic Debugging Tasks
Chapter 3 gives hands on examples of the basic .NET debugging tasks such as:
· Thread management
· Display stack traces
· Display local variables
· Breakpoint management
· Dumping heap based objects
· .NET exception model and how to analyze in the debuggers
· Basics of postmortem debugging
· Remote debugging
Part II – Applied Debugging
Par t II is a practical approach to debugging common .NET problems encountered in the development process. Each chapter is dedicated to a specific CLR component and/or technology and begins by detailing the inner workings of that component. Subsequently, a number of common problems related to the specific technologies are discussed and how the debuggers and tools can be used for root cause analysis.
4. Assembly Loader
The complexity of .NET applications can range from simple command line applications to complex multi-process/multi machine server applications with a large number of assemblies living in harmony. In order to efficiently debug problems in .NET applications one much be careful to understand the dependencies of .NET assemblies. This chapter takes a look at how the CLR assembly loader does its work and common problems surrounding that area.
5. Managed Heap and Garbage Collection
While .NET developers can enjoy the luxury of automatic memory management, care must still be taken to avoid costly mistakes. The highly sophisticated CLR garbage collector is an automatic memory manager that allows developers to focus less on memory management and more on application logic. Even though the CLR manages memory for the developer, care must be taken to avoid pitfalls that can wreak havoc in your applications. In this chapter we look at how the garbage collector works, how to peek into the internals of the garbage collector and some common programming mistakes related to automatic garbage collection (non memory resources, memory fragmentation, finalizer problems etc).
6. Synchronization
A multithreaded environment allows for a great deal of flexibility and efficiency. With this flexibility comes a lot of complexity in the form of thread management. To avoid costly mistakes in your application, care must be taken to ensure that threads perform their work in an orchestrated fashion. This chapter introduces the synchronization primitives available in .NET and discusses how the debuggers and tools can be used to debug common thread synchronization problems. Scenarios such as deadlocks, lock contentions, sync blocks, thin locks and thread pool problems are discussed.
7. Interoperability
.NET relies heavily on underlying Windows components. In order to invoke the native Windows components the CLR exposes two primary methods of interoperability:
1. Platform Invocation
2. COM Interoperability
Since the.NET and Win32 programming models are often very different, idiosyncrasies often lead to hard to track down problems. In this chapter we look at some very common mistakes done when working in the Interoperability layer and how to use the debuggers and tools to troubleshoot the problems.
Part III – Advanced Topics
8. Postmortem Debugging
Quite often it’s not feasible to expect full access to a failing machine so that a problem can be debugged. Bugs that surface on production machines on customer sites are rarely available for debugging. This chapter outlines the mechanisms for debugging a problem without access to the physical machine. Topics discussed include the basics of crash dumps, generating crash dumps, analyzing crash dumps etc.
9. Power Tools
Introduces the reader to power tools such as Debugging via Powershell , IISDiag and more.
10.CLR 4.0
This chapter is reserved for any substantial enhancements coming out while the book is being authored/published.

Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.
This book's goal is to change that. In it, the authors of twenty-five open source applications explain how their software is structured, and why. What are each program's major components? How do they interact? And what did their builders learn during their development? In answering these questions, the contributors to this book provide unique insights into how they think.
If you are a junior developer, and want to learn how your more experienced colleagues think, this book is the place to start. If you are an intermediate or senior developer, and want to see how your peers have solved hard design problems, this book can help you too.

Every programmer and software project manager must master the art of creating reusable software modules; they are the building blocks of large, reliable applications. Unlike some modern object-oriented languages, C provides little linguistic support or motivation for creating reusable application programming interfaces (APIs). While most C programmers use APIs and the libraries that implement them in almost every application they write, relatively few programmers create and disseminate new, widely applicable APIs. C Interfaces and Implementations shows how to create reusable APIs using interface-based design, a language-independent methodology that separates interfaces from their implementations. This methodology is explained by example. The author describes in detail 24 interfaces and their implementations, providing the reader with a thorough understanding of this design approach.

The vibrant and rich Android development platform, created by Google and the Open Handset Alliance, continues to be a platform in its truest sense, encompassing hundreds of classes beyond the traditional Java classes and open source components that ship with the SDK. Android’s continued growth includes support for Flash and Flash Gaming Apps, WIFI tethering, improved performance, WebM or WebMedia integration for HTML 5 based video and other multimedia APIs, Chrome OS (WebOS) integration, and more. With Beginning Android 3 , you’ll learn how to develop applications for Android 3 mobile devices using simple examples that are ready to run with your copy of the SDK. Author, Android columnist, developer, and community advocate Mark L. Murphy will show you what you need to know to get started programming Android applications, including how to craft GUIs, use GPS, Multi-touch, Multi-tasking, and access web services. What you’ll learn Discover Android and how to use it to build Java-based mobile applications for a wide range of phones and devices. Create user interfaces using both the Android widget framework and the built-in WebKit-powered Web browser components. Utilize the distinctive capabilities of the Android engine, including location tracking, maps, and Internet access. Use and create Android applications incorporating activities, services, content providers, and broadcast receivers. Support Android 3 and earlier devices, including dealing with multiple Android OS versions, multiple screen sizes, and other device-specific characteristics. Create Flash game and other apps on Android. Build and experience the array of new WebM video and other multimedia APIs for Android and more. Who this book is for This book is aimed at people new to mobile development.

As programmers, we've all seen source code that's so ugly and buggy it makes our brain ache. And let's be honest, we've all written code like that. With this book, you'll learn to write code that's easy to read and understand. You'll have more fun and your coworkers will love you.
The Art of Coding focuses on the nuts and bolts of programming, with simple and practical techniques you can use every time you sit down to write code. You'll find tips throughout the book, with easy-to-digest code examples, helpful illustrations, and cartoons for fun.
* Learn to pick variable names that are "dense with information"
* Organize your loops and conditionals so they're easy to understand
* Make your comments short and sweet
* Recognize when your code is doing too many things at once
* Write tests that are concise, but thorough
* Master the art of breaking hard problems into many smaller ones

Vim, a vast improvement over its classic ancestor vi, is a serious tool for programmers, web developers, and sysadmins. No other text editor comes close to Vim for speed and efficiency; it runs on almost every system imaginable and supports most coding and markup languages.
Learn how to edit text the “Vim way”: complete a series of repetitive changes with The Dot Formula, using one keystroke to strike the target, followed by one keystroke to execute the change. Automate complex tasks by recording your keystrokes as a macro. Run the same command on a selection of lines, or a set of files.
Discover the “very magic” switch, which makes Vim’s regular expression syntax more like Perl’s. Build complex patterns by iterating on your search history. Search inside multiple files, then run Vim’s substitute command on the result set for a project-wide search and replace. All without installing a single plugin!
You’ll learn how to navigate text documents as fast as the eye moves—with only a few keystrokes. Jump from a method call to its definition with a single command. Use Vim’s jumplist, so that you can always follow the breadcrumb trail back to the file you were working on before. Discover a multilingual spell-checker that does what it’s told.
Practical Vim will show you new ways to work with Vim more efficiently, whether you’re a beginner or an intermediate Vim user.
All this, without having to touch the mouse.