Volume Number: 15 (1999)
Issue Number: 5
Column Tag: MacTech Online

May 99 Online

by Jeff Clites <online@mactech.com>

Longtime Mac users are experiencing a bit of culture shock in facing the reality that Apple's new OS family, Mac OS X Server and the soon-to-exist Mac OS X, is built on a Unix foundation.

Developers who come from a computer science background will surely be no strangers to Unix and its command line - I doubt that the Macintosh was even mentioned in any of their classes. But for those of us who got here via a different, pure-Macintosh route, it can be disorienting. After all, Unix was one of the unfriendly operating systems that Apple had in mind when they dubbed the Macintosh the computer for "the rest of us", right?

But after you get past the initial strangeness it begins to make a lot of sense. Unix can form a stable core upon which to build an OS. And if you continue to think in the usual metaphors, you can look at it this way: you probably don't want to build your house entirely out of concrete (it would be pretty bleak), but you certainly want to build it on top of a concrete foundation. So if everything goes as planned, when the consumer release of Mac OS X arrives, casual users will be no more aware of its Unix underpinnings than your guests are of the concrete walls in your cellar.

But what does it really mean that Mac OS X is "built upon a Unix core"? This month we are going to try to answer this question and find out a little bit more about the history and culture of Unix, and track down some sources to help developers find out what they need to know to feel comfortable with this new facet of Apple's OS.

Unix originated in the late 1960s at AT&T Bell Labs. Due to liberal academic licensing policies, universities began using Unix for teaching and research, leading to the development of BSD (the Berkeley Software Distribution) at UC Berkeley. AT&T continued to develop their own version, System V, and these two versions have formed the basis of nearly all subsequent Unix derivatives. BSD, owing to its academic heritage, tended to be more experimental and innovative, but much cross-pollination continued after the initial division. 4.4 BSD-Lite was the last version to be released by UC Berkeley (the "Lite" refers to this version's freedom from any AT&T copyrighted code). The main currently-active systems derived from BSD are NetBSD and OpenBSD, which are available for various hardware platforms, as well as the Intel-centric FreeBSD and the commercial BSDI. You can read more about the history and current state of BSD at the following URLs.

Knowledge Base - Do you have a brief synopsis of Unix history?

http://kb.indiana.edu/data/acve.html

Knowledge Base - What is BSD Unix and what are FreeBSD, NetBSD, OpenBSD and BSD/OS?

http://kb.indiana.edu/data/agom.html

[comp.unix.bsd] NetBSD, FreeBSD, and OpenBSD FAQs

http://faqs.colombianet.net/386bsd-faq/top.html

The return of BSD - SunWorld - January 1999

http://www.sunworld.com/swol-01-1999/swol-01-bsd.html

Nick Moffitt's $7 History of Unix

http://crackmonkey.org/unix.html

Mac OS X Server is based on the Mach kernel, originally developed at Carnegie Mellon University. The kernel provides only very basic services: processor scheduling, interprocess communication, and management of virtual memory. Mach is designed to be small; this makes it easy to understand (and therefore debug), as well as fast and efficient. (I forget who first pointed out that the only real way to speed up code is to make it do less). All other system services are provided by a server application (or a set of them). This is how it is possible for both Mac OS X Server and MkLinux to be based on the Mach kernel (albeit different version) - in a very real sense, Mach is the operating system, and Linux and BSD are applications. Although it's invisible to the programmer, what would have been a system call under the MacOS (or 4.4 BSD) is really an interprocess message under Mach. So these are the two senses in which Mac OS X Server is "based on" Unix: the Mach kernel has a Unix heritage, and 4.4 BSD-based application compile and run by virtue of the BSD "personality".

You can get the official scoop on Mach and its relation to Mac OS X Server in Apple's developer documentation. Carnegie Mellon also has a Mach site with a collection of technical information and publications. Of special interest is the introductory paper "Unix as an Application Program". Also be sure to check out the Linux Journal article "Linux? On the Macintosh? With Mach?", by Vicki Brown.

Apple's Mach Reference

http://developer.apple.com/techpubs/macosxserver/System/Documentation/Developer/OperatingSystem/Mach.pdf

CMU CS Project Mach Home Page

http://www.cs.cmu.edu/afs/cs.cmu.edu/project/mach/public/www/mach.html

Unix as an Application Program (in PostScript form)

ftp://ftp.cs.cmu.edu/project/mach/doc/published/mach3_intro.ps

Linux? On the Macintosh? With Mach?

http://www.linuxjournal.com/issue37/2093.html

I would imagine that most Macintosh programmers have no intention of writing Unix-style applications just because they can (at least I hope not), but nonetheless they want to be comfortable with the Unix side of Mac OS X Server. In this light, I recently began to peruse three books which cover the spectrum of topics about which you are likely to be curious.

As its title implies, The Unix Philosophy, by Mike Gancarz (ISBN 1-55558-123-4) explains the motivation and culture behind the design of Unix systems. It's a pleasant read - it's short and non-technical, focussing on ideology. For a user-level introduction, Unix: Clearly Explained by Richard L. Petersen (ISBN 0-12-552130-8) covers the basics, including pipes, the most common command-line tools, the various shells, and the vi and emacs text editors. These two books could be read in either order, depending on whether you like conceptual background before concrete "how-to", or vice-versa. One thing they don't cover is the Pico text editor, which Apple has included with their distribution. If you are forced to boot into single-user mode and fix something via the command-line interface, then you will find Pico more friendly in your time of crisis than vi or emacs. Fortunately, NC State University has a nice online Pico tutorial, and Indiana University has a convenient reference guide that you can download in pdf format. (And of course, there are always the man pages.)

PICO tutorial

http://www2.ncsu.edu/ncsu/cc/pub/tutorials/pico_tutor/pico_intro.html

The Pico text editor under Unix: A quick guide

http://www.indiana.edu/~ucspubs/b103/b103.pdf

At the other end of the spectrum is The Design and Implementation of the 4.4BSD Operating System (ISBN 0-201-54979-4). Written by the original system architects, it covers all of the technical details of the design of BSD and the algorithmic choices which underlie it. It isn't programmer's documentation per se (it doesn't teach you how to write Unix applications), but it will answer all of the architectural questions that the curious developer might ask. It's heavy reading, especially if you are new to Unix, but it's kind of comforting to have the book with all the answers.

These and a truck load of other links are available from the MacTech Online web pages at www.mactech.com/online/.