Mac OS X Internals: A Systems Approach

I'm a professional Mac/Unix developer for a relatively large, very well-known, and generally well loved company. I'm also a sort of junkie for good tech books, and this one is among the best. I've read a lot of Amit's technical writings on his website over the years, and they were always chock-full of awesome tid-bits, had unmatched depth, and were written very well. So, when I heard he was writing a book, I could hardly wait to get my hands on it. And it didn't disappoint. It's a thick book, but I had trouble putting it down and read it cover to cover. It was filled with more detail than I could've imagined, but it was presented in such a way as to not lose the reader. Each page seemed to spark a new question in my mind about how something works, only to be answered by the next page. The book goes into great detail about the boot process, OpenFirmware, EFI, the PowerPC 970FX processor, Mach (the best info I've seen), virtual memory (and physical memory), launchd, Spotlight, and much more. It covers so many areas that are scarcely covered elsewhere, and will answer questions that you didn't even know you had. This book is great for those interested in operating system and kernel design, but also it's a must-have for anyone who's serious about Mac OS X development.

Most Mac OS books were authored by the same handful of recycled authors, except the occasional new one. The UNIX underpinning of OS X enriched Mac libraries with new authors and perspectives, however, all the books were either Beginner or Intermediate regardless of the classification on the back. I had been eager for an OS X equivalent of Windows Resource Kits or the many other very detailed books on Windows such as Windows XP Internals. Too bad I lacked the grey matter to undertake the task myself. Mac OS X Internals is the only advanced OS X book available today because of the type of book it is. It is a Mac-oriented systems text that would fit nicely in a course on Operating Systems or Systems Architecture. The typical Operating Systems offering in a public book store doesn't approach half the detail of advanced Computer Science texts because they are written for those who create the technology rather than merely use or support it. Mac OS X Internals will appeal to anybody with genuine interest in the theory of operating systems, and the details herein will enhance your grasp of OS X in whatever capacity you use it. It will therefore appeal to programmers, systems administrators, technical support, and power-users who have outgrown their Mac library. Here's a book that doesn't confuse a device driver for a kernel extension, and details the architecture of OS X to the level of semaphores and atomic operations. After reading this book, all others feel introductory. If you don't average at least one new fact per page, then you may be suffering from undiagnosed Attention Deficit Disorder, however, I suggest you browse the Table of Contents before purchase.

This book has to be one of the most comprehensive treatments of any operating system ever. I read through the sections with which I am most familiar (file systems, Spotlight and HFS). The level of detail and understanding expressed in those sections is very impressive. I thought I might find some errors or at least niggling details that weren't quite right but I could not find any. Perusing the other sections of the book I even found that I learned a few things. The depth and breadth of this book make it a must-have for anyone involved in MacOS X programming (IMHO). Even if you're not a kernel programmer, there are many details and pieces of information that explain how and why things work the way they do.

This book is essential for anybody that wants to understand the inner workings of Mac OS X, which should include all serious OSX software developers. This book is also a must read for any technical users of OSX, in order for them to know what's really underneath the covers, even when they are not writing software for OSX. I am the second type of reader: I am a researcher with Microsoft Research, where I work mostly on operating-systems related topics. However, at home, I've had machines running OSX since version 10.0, and I have been waiting for somebody to write this book since then. (In fact, I was eager enough to review portions of an early draft of this book.) The published book is a bit daunting, at over 1600 pages (bound in a sturdy format, which should tolerate heavy use). However, as quickly becomes clear, it covers a complex topic in such substantial detail that it is hard to see how it could be shorter. Also, given the book's size, and the amount of material it covers, the price seems very reasonable. Fortunately, despite its size, the book is well structured and has a good index, so information is easy to find. Also, the book is written in an highly readable style, which helps the reader maintain attention. As a result, the book is quite pleasant to browse and read a few dozen pages at a time (as I've been doing for a while, as light bed-side reading). One of the reasons this book is so useful is that, even more so than other modern operating systems, OSX is a complex mix of new and legacy technologies, both proprietary and open source. So to understand OSX, one has to understand parts of Mac OS 9, Mach, BSD Unix, NextStep, GNU/Linux as well as technology novel to OSX. This book does a good job of covering all of these influences, and give enough historical background to understand why OSX is like it is. Of course, it is possible to successfully use OSX as a "Unix", without knowing about other APIs or subsystems---however, this makes it impossible to use much functionality, and to truly understand the entire system. This book covers most essential OSX abstractions and concepts, much like the Magic Garden Explained does for System V, the "red daemon" books do for BSD, and the Windows Internals books do for NT. So, the reader will know how scheduling, memory management, synchronization and inter-process communication works, how Mach tasks relate to processes, and other such essentials. Some of the other operating system books (e.g., the BSD books) relate what they discuss to particular files and functions of the source code. As far as I can tell, this book does this to an unprecedented extent, describing in detail the Darwin sources for OSX and how they implement the concepts being discussed. In particular, for important system aspects, such as booting and initialization, and scheduling, the data and control flow between source functions is given in complete detail. So, for anybody wanting to explore the Darwin sources,

I had the opportunity to review the draft manuscript of Amit Singh's Mac OS X Internals book. With so many different types of operating systems books out there, let me try to place the book to give a better idea what to expect. There are general introduction books that normally introduce the operating system to the reader, without explaining what is actually going on. We have concept books (I put "The Design and Implementation of the FreeBSD Operating System" in this category) which are usually a good introduction to a new system. I used to be a great fan of this type of books, and I still enjoy reading them, but I don't anticipate much new from them. The fact is that operating systems today differ not that much in concepts and abstractions but more in their implementation. Then we have the kernel programming books that either cover the kernel programming in general, like Linux Kernel Internals, or focus on specific parts of the kernel, like Linux Device Drivers. The Mac OS X Internals book falls into a category that I call OS Internals books category. Books in this category (like the popular Inside Windows books) are similar to the concept books in the sense that they are not focusing on solving some predefined problems, but rather share knowledge. They differ from the concept books in that they approach the concepts from implementation point of view. In recent years I have become a great fan of this type of books. Books in this category are both very enjoyable for anyone interested in the OS but also very useful for application developers. Actually Amit's book does start off as more of a concept book, and in the first part of the book he gives a great overview of the Mac OS X system, which should be an interesting read even for people not using Mac, but with general interest in operating systems. I found it particularly interesting to read because OS X is so different from other operating systems I know and love, like Linux and Solaris. We've all heard how Mac OS X is built on top of the Mach kernel, uses large parts from BSD, supports backward compatibility via the Carbon API, etc. Not until I had read the first part of this book I fully understood how all the pieces fit together. In my opinion the first two chapters are rich enough in content and interesting and fun to read for me to recommend this book to anyone interested in operating systems, regardless if they will ever do any programming on a Mac. The remaining parts of the book cover OS X in a logical order, from the bottom up. Since the book is more focused on educating the reader of how things work rather that trying to teach how to do some particular task (like a network programming book would do) it is important to realize that the book is covering a lot of content, which may not all be of interest to you. If you are more interested in some particular area it is probably wise to jump directly to the appropriate chapter. The book covers a lot, including the xnu kernel, the bo