• Create BookmarkCreate Bookmark
  • Create Note or TagCreate Note or Tag
  • PrintPrint

BSD Philosophy

One of the complaints you might have heard from people regarding Apple's new OS is that it is based on immensely old operating system technology. They're right! The roots of Unix lie almost in the roots of modern computing itself. The thing that they're wrong about is their claim that this is a Bad Thing. Unix development started more than three decades ago, and the operating system that you can use today is the product of thousands upon thousands of developers work and improvements. Along the way, Unix has picked up some very powerful design concepts and some wonderful solutions to problems common in the computing world. Much of the “Unix way” is based on the idea of abstracting interfaces into the simplest possible terms. Initially, this was simply because the OS was experimental, and the simplest possible interface—one that wouldn't need fiddled with later—was the most expedient to construct. Over time, this “do it the easy way” methodology has evolved into a very powerful design concept: abstraction. This concept will be mentioned time and again as it makes its appearance in different topics throughout the book. As an initial explanation, though, an example will provide immediate understanding. Among many other concepts, Unix abstracts the notion of things that can be read from, or written to, as files. To Unix, everything from which data can be read is treated as though it were a file, and everything to which data can be written is treated as though it were also a file. Why? Because after you've developed an in-OS methodology to control reading and writing to files, it's a nuisance to have to implement almost identical methodologies for reading and writing to the network, or writing data to printers, or reading data from the keyboard. Instead, it's considerably easier to write an abstraction layer that talks to the particular device, and makes it appear to the OS as just another file. If you make your printer look like a file, printing is simply “writing to a file” for any application. If you make your keyboard input look like it's coming from a file, any application can automagically accept input from either the keyboard or an actual on-disk file, without knowing the difference.

What starts as a time-saving implementation turns into a powerful interface feature, allowing the addition of arbitrary devices, without needing to implement new OS features—just write something that makes the device “look like a file,” and suddenly the OS can use it. This notion of abstraction ends up being very powerful for the end user, and similar abstractions will be pointed out in the sections to come.


PREVIEW

                                                                          

Not a subscriber?

Start A Free Trial


  
  • Creative Edge
  • Create BookmarkCreate Bookmark
  • Create Note or TagCreate Note or Tag
  • PrintPrint