Operating Systems

Review by Chris Mcclanahan:

Although I had to buy this book for a class, I do enjoy reading it. The book stays current by focusing on modern multi-core processors, and relating most concepts to Linux, Windows, and Solaris (plus sometimes others) operating systems. It is fairly easy to read, and there are programming exercises at the end of each chapter to highlight concepts. This book will definitely get your feet wet when learning operating system concepts.

Review by wiredweird:

This provides a solid introduction to the basics of operating system (OS) internals. After an introductory section, this covers the major subsystems in an orderly progression: processes, memory, storage, protection, distributed systems, and special purpose systems. Although I might quibble with some of the ordering, (e.g., virtual memory vis a vis process management), this gives a firm foundation for anyone teaching introductory OS internals. As an aside, instructors should also be aware of the additional support they’ll find at the book’s web site.

I have no real objections to this book, but find that some of its emphasis won’t suit all readers. For example, 99% of all processors don’t run Windows or Linux. Instead, they run your DVD player, car air bags, microwave, digital watch, and just about everything else with a power cord or battery. Engineering students headed for embedded system development will need supplementary material. Also, like every other undergrad text I know, this underplays the critical importance of standards in everything from APIs and file system structures to network protocols and safe coding guideline.

I’ve taught from this book and from Tanenbaum and, to tell the truth, have no strong preference between the two. They present comparable material at roughly the same level, both offer good case studies, and both offer on-line support to students and instructors. Each outweighs the other on specific topics but, on the whole, that seems to balance out. I note that some reviewers object to this book’s level. To them, I can only say: that’s life. OS development is at least ten times as hard as developing mainstream applications (as measured by programmers’ output of debugged code), so it will require some programming knowledge to follow discussions of OS internals. Railing against obviously important prerequisites says more about the speaker than about the book.

– wiredweird

Review by Richard Bejtlich:

Tanenbaum’s book is a thorough yet accessible introduction to the design and implementation of modern operating systems. This second edition explains the trade-offs developers must make and shows readers how OS’ have matured since the 1960s. Knowledge of programming in C is helpful, especially if the reader wishes to complete the exercises following each chapter. I gave the book five stars for its content, delivery, and humor, all of which helped me learn a difficult subject in an enjoyable manner.

“Modern Operating Systems, 2nd Ed” (MOS:2E) is very well-written, which may surprise those who suffer while reading other hardcover college texts. The book introduces problems facing developers, then helps the reader understand both simple and complex ways to address these issues. Tanenbaum’s style is lively and informative, like the cover of his books. He appears knowledgeable and opinionated — especially concerning problems with the Windows OS — but he can back up his assertions.

The best features of MOS:2E are found in chapters ten and eleven. Here Tanenbaum illuminates UNIX and Microsoft Windows 2000, respectively, building upon the material found in the previous nine chapters. He gives real reasons why Windows suffers security problems, such as internal complexity, code bloat, and design choices. UNIX is also critically evaluated, but stands up better to Tanenbaum’s scrutiny.

I don’t recommend computer novices read MOS:2E. One needs a certain amount of interest and motivation to digest this material, and Tanenbaum’s explanations of some concepts did not seem sufficient. However, after having finished this 900 page tome, I feel more comfortable reading about design issues for the Linux kernel or the FreeBSD scheduler. If you’re looking to learn the how and why of operating system design and implementation, I strongly recommend MOS:2E.

Review by Ricardo Diz:

I think this book is a great book on OS. It’s easy to read (don’t forget Tanenbaum humor :)), it explains difficult issues using simple analogies and is certainly an up-to-date book on the field.It has one chapter covering Unix (and Linux) and another one for Windows 2000, two of the more important Operating Systems well explained here.The Chapter on processes and threads is great. It really clarifies the difference between processes and threads.Although I found the book as easy to read as it can get, I must admit that I had litle bit of a hard time reading that Memory Chapter. I’d prefer it didn’t had so many algoritms. I shorter chapter would probably be better, at least for me ;).It also has a chapter on security, a must have nowdays. If you are a first-time learner on Operating Systems I think this is the one.

Review by Comp Sc. Instructor:

Definetely targeted towards the sophomore/Junior level students. This book goes into generic concepts used by most operating systems – i.e., what happens when a program is loaded into memory? How do processes make system calls to the kernel, how is deadlock among several programs competing for the same resources resolved, what is the characteristics of real-time operating systems etc.

I have adopted this book for teaching the operating systems course. I find that students, in general, appreciate this book as it is very readable. I believe a good text book should have the following qualities: It should be light enough to read it in bed, the fonts should be large enough to not give a headache after an hour of reading, should be written in clear lucid style with plenty of figures and should have decent binding. I believe this book qualifies in all those aspects.

However, I do have one unpleasant comment. I hate it when authors keep coming out with new editions with just small delta changes – forcing students to buy high priced editions because some professors could care less about the cost of books to students (after all, we profs get them for free). The 7th edition is not a whole lot different than the 6th edition (about 2 or 3 new chapters included in the 7th edition). Considering that you can buy a used 6th edition for half the price of a new 7th edition, I recommended my students to go with the 6th edition instead and chose to just teach them some of the additional materials from the 7th edition.

What I would have liked to see in this book – greater detail (perhaps with some psuedocode) on the workings of the kernel and how programs can take advantage of it (I guess I am thinking along the lines of Steven’s UNIX programming book).

Review by John Matlock:

This new seventh edition of the book has been brought up to date to include recent developments in operating systems such as Windows XP and the new small footprint operating systems that work in hand held devices such as the Palm and in cell phones. In addition the text now corresponds to the suggestions from Computing Curricula 2001 for teaching operating systems.

Most of the book is on general purpose operating systems such as Linux and those from Microsoft. But at the end of the book there are chapters on other types of operating such as Real Time Operating Systems and MultiMedia OS’s.

Finally there are some chapters which the authors call case studies. In these, one chapter goes into a detailed discussion of Linux, another chapter covers Windows XP. Chapter 23 covers several early operating systems that helped to define the features that make up modern os’s. These include: Atlas, XDX-940, THE, RC 4000, CTSS, MULTICS, OS/360, and MACH, along with brief mentions of several others.

Note that this not a book on how to use operating systems, this is a book on how operating systems are designed. It is intended for upper level undergraduate students or first year graduate students.

Review by Ed Hayes:

This is a good introduction to how operating systems work — not nearly as technical as hard-core books written for computer scientists. The first 11 chapters explains the common basics of all operating systems, how OS’s manage main memory, processors, devices, files etc. The last 5 chapters describe specific OS’s for PCs and mainframes, and how they apply the features discussed in the first 11 chapters. Being an “old-teckie-timer”, I’ve worked with the big, medium, and small boxes, in several operating systems, and many languauges. I’ve taught this stuff to non-techs, too. My task is always to “simplify and communicate, without losing the meaning”. I’m a techo-translator. So are Flynn/McHoes.As a classroom textbook or a supplement to a technical CS book, it’s great because it’s easy to read and understand. But it’s not “OS for Dummies.” I recommend it to anyone who wants to understand the nuts and bolts of operating systems without having to read or write the code that runs the machine.

Review by Siddhardha:

The book is divided into two parts. The first part deals with the basics of operating systems which includes memory manager, processor manager, file manager, device manager and network manager. This part is presented in such a way that it can be easily comprehended by even novices and the authors did an excellent job here. The second part of the book deals with specific operating systems. Details about MS-DOS, Windows 2000, UNIX, OpenVMS Alpha and OS/390 operating systems are provided in this part. While there are few locations where the explanation is not very clear, for the most part it is understandable.

This book was a required text for an undergrad course in Operating Systems I was taking. I read it from cover to cover and overall I liked it very much. I would have liked to see more visuals, examples and exercises. I will not sell this book but I will keep it for future reference. Like another reviewer mentioned, some knowledge about computer peripherals is necessary to study this book, however no specific language is assumed. Highly recommended to those who are new to this topic.

Review by :

I have taught operating systems at the graduate level for the last 5 years. In other areas of computer science, I’ve been spoiled by classic textbooks (e.g. Aho, Sethi and Ullman’s “Compilers: Principles Designs and Tools”, aka “The Dragon Book” for compiler design, Hennessy and Patterson’s “Computer Architecture a Quantitative Approach”, etc.) Computer Operating systems is a mature field, yet no textbook reaches classic stature in Operating Systems. Previous editions of the textbook have had serious errata in the problem sets (it i embarrassing to assign unsolvable problems to students) I no longer use any problems from this book as a result.However, among Operating Systems textbooks, there are primarily 2 categories, those with example code (e.g. Tannenbaums) and survey books. This is a survey book (sometimes called theoretical, but not in the Automata Theory or Algorithms sense). It has some overview of design principles and some analysis, which makes it better than the others I’ve seen, but still leaves a bit to be desired, I feel it is still a bit too qualitative. I’d like to see more back of the envelope analysis (like say Patterson and Hennessy’s book). The section on scheduling is pretty good, with some nice analysis, and the queueing theory section is useful for first year grads and upper division undergrads. Still, I need to assign quite a bit of additional literature.

Review by Michael Lehenbauer:

My Operating Systems course used this book and we were assigned chapters to read every week. It was incredibly painful. This book does not read well at all. The ideas aren’t very well motivated. Many times, Stallings just enumerates a list of alternate strategies for solving a problem without talking AT ALL about how the strategies came or why we should think about all these different strategies in the first place. He just lists and describes them. Very dry.

I eventually stopped reading the book and just used it as a reference when doing our open book online quizzes. This worked well. It’s easy to find specific information (“How does Round Robin Scheduling work?”) and the explanations are reasonably clear and concise. But if you’re trying to actually read it sequentially to get the general idea, you’re in for some pain (and sleepiness).

Review by Amgad Okasha:

I only got this book for my OS class. It’s academic book after all. It did the job well!

Review by OldTechie:

Guide to Operating Systems (enhanced edition) by Michael Palmer and Michael Walters, does the job if you need it for a college course.

It is becoming a bit dated now that Windows 7 is out. Vista is not covered in great detail.

I don’t expect to work much with Linux and will probably never see some of the server systems they talk about.. But I still had to remember it long enough to take the tests.

Seems to me they want to make a real point how all operating systems, older windows, Linux, and the Mac OX can all be networked together.

Wish I could remember half of what is in that book now, less than a year since I used it.

Review by Geogia Tech Student:

First off, don’t be fooled by people who claim this to be an “easy read”. It isn’t … reading the entire book will take weeks, as the text is packed with information, not to mention exercises following each section. That being said, I highly recommend the book. It provides a thorough introduction to operating systems basics, from scheduling to terminals, along with source code. Don’t expect to absorb it all at once!

Review by W. Faught:

This book is written by Tanenbaum, the main guy behind Minix, which is what Linux was based on. It provides good overviews for basic OS concepts like memory management, file systems, processes, etc. The concepts in this book book are intimately tied to examples of the Minix OS, which is a good thing.

To those who would rather see examples from Linux: Minix is a compact and modular OS, which is why it’s a good choice for examples. The book contains the entire source code at the back for easy reference. Yes, the OS is that small. That’s a good thing when you’re trying to figure out how virtual memory works or what have you. You’d be lost trying to learn this stuff from Linux. Above everything else, the code is ***well-commented*** compared to Linux, a major plus. You won’t find any “/* major hack */” comments, either. 😉 Minix leaves out all the crap that Microsoft and Linux throw into the kernel that make it unstable in the first place. Learn about the bells and whistles later when you can do the basics.

I encountered two instances where the book wasn’t updated to reflect changes in the OS, which were annoying to deal with. Also, I found a spelling or punctuation error about every ten pages, which was annoying for such a pricey book. Overall, however, the book is extremely usable and understandable. It’s easy to pick up concepts from this text.

Review by :

I am using this book because i’m taking the ugrad OS course at CU Boulder. Guess what university the author is from. yeah, that’s right. This is, quite possibly, one of the worst books ever written by a human being. If, hypothetically, one were to forgive the book for blatantly incorrect examples that obviously haven’t even been checked or reviewed and have spawned more than a few bewildered discussions among my fellow students and I, for rediculous project suggestions, for its condescending tone, for the obnoxious little graphics and second-rate dull grey paper on which they’re printed, it still remains that the book does an atrocious job of treating the history and current practice of operating systems. It seems to be leaving us with a horribly skewed general prospective on the field and a paucity of actual knowledge–thus, not only are we ill-prepared to design an operating system, but we are worse programmers for having adopted Nutt’s sick and deviant way of thinking. If this seems too vague for you, let me simply say that more than a few vague, general discussions are clearly based not on UNIX, not even on NT, but on MS-DOS. The fact that i recognize the lineage of his thinking is a major source of embarrassment for me, but I must share it with you lest this book corrupt yet more fresh young minds. Those who enjoy kneeling and worshiping before mistakes IBM made twenty years ago will get a real kick out of this book–there are detailed discussions of bizzare things IBM did on old two-ton mainframes, extensive discussions of batch job scheduling and seek algorithms for ten-inch disk packs. Yet, for the rest of us, I can only say: if you have a copy of this book, I advise you to burn it immediately. I sure wish I could. If i can save just one poor soul from this book, I will die a happy man.

Review by Rob F.:

The content is well organized and the relevant information seems to be present. However, a lot of the pseudocode is blatantly wrong. This would be very misleading for an initiate to operating system design and implementation, the target audience for this book. If you know enough to recognize the errors in the pseudocode, you’re too advanced to be reading this book. If you know less, you shouldn’t be reading this book because its errors will undermine the foundation you’re hoping to build. Your money is better spent on another book.

Review by Michael J Woznicki:

Looking for the A+ certification? As you know this certification has 2 exams, I for hardware and 1 for the Operating systems. This book is a great prep tool for the OS section as it covers several key operating systems and few that aren’t on the exam.The book starts off with a hardware overview, which is very helpful in the understanding of software. Then you deal with the older operating systems like Windows 3.X and DOS, this is a nice foundation to learn the roots of the operating system.Then comes NT, 2000, XP and there is even section for the MAC OS and Linux group. What I liked about this book was the exercises and labs; they would prove to very helpful in understanding certain concepts.About the only thing missing is cds with evaluation copies of the operating system(s), in case you don’t have access to them. Overall this book is a great compliment to the Mike Meyers All in One A+ Study Guide. As an Instructor, this book becomes a valuable add on to the curriculum.

Review by Reesie:

As an IT student, I occasionally run into material that I find stale, boring, and overwhelming. This book isn’t like that. I am able to review study material that is not only useful, but fun to read! You can’t go wrong with this book, it is a valuable resource to learning OSs and what makes them tick.

Review by Dennis Deems:

There are some good things to say about this book. It’s written in clear, plain language, with helpful illustrations and code examples. Key terms are highlighted and defined concisely.

Unfortunately there are many more bad things to say about it.

Let’s face it, this subject is about as exciting as counting freckles. The baroque ugliness of the book’s design, intended to suggest in appearance an old notebook of Leonardo da Vinci, has already been mentioned by other reviewers. It certainly doesn’t make reading easier.

The authors have tried to liven things up by including anecdotes, biographical sketches, mini-case studies, and other sidebar material. It’s a good-hearted but wrong-headed effort. None of this material is necessary, and it only serves to make a long story longer. The book is over 1200 pages long. The last thing a college student needs in his backpack is more weight to carry around all day. And who’s actually going to read this stuff? (Hmm, let’s see… what to do with my study time? fix my data structures code? perpare for my Calc exam? no, I think I’ll read some speculation about the origin of the word “glitch”.)

It isn’t just the sidebar fluff that pads the book’s length. A typical chapter finishes up with a two-page summary, four pages of glossary (unnecessary if you’ve read the chapter, where the terms are already defined and set in colored type), four pages of exercises , and four pages of bibliography. Yes, a bibliography is appended to each chapter. I am not talking a simple “suggested for further reading”. I am talking works cited, 100 or more per chapter. In one case the bib is 13 pages long, with over 400 citations. Who is this for? How many undergraduate students are going to pursue these references?

The makers of this book have employed some crafty strategies to pad their work. Likely to go unnoticed is the redundant fifty-page glossary at the very end of the book, in case you missed the ones at the end of each chapter. The book’s table of contents is unnecessarily detailed, with an entry for chapter headings, subdivisions, sub-subdivisions, as well as each sidebar. Next comes a list of every illustration and code example. In case you need to find one fast, or something. There follows a twenty-page preface which details the book’s features, and includes a “Tour of the Book”, an overview of the eight parts and 21 chapters of the book. The book’s actual text doesn’t get started until 66 pages in.

I’m guessing this sort of content goes over well with textbook committees, because it means they don’t have to read the book to get a sense of its content. I can imagine no other reason to include it unless it is to drive up the price of the book.

Review by Charles Ashbacher:

In my career, I have taught mathematics and computer science at the college level, developed and delivered courses in corporate training, taught classes in community education and occasionally engage in private tutoring. In the rapidly changing field of computer science, if you do not study, study and study, it will not take long before you are no longer on the cutting edge. While the continued existence of programming languages such as COBOL and other legacy systems does provide employment, they are not circumstances one should rely on for a long-term livelihood. Therefore, I am always trolling for new and better material for use as textbooks or for self-study. Having taught a CS major course in operating systems several times in the last decade, I have a natural interest in this book.

I found it to be very detailed and complete, while most students will probably skip the historical notes, they do provide excellent reference points concerning the development of operating systems. I would use some of them as starting points for in-class discussions of how some of the critical problems in operating systems development were solved. A few self-review questions with answers appear at the end of each section. The following items are included at the end of each chapter:

*) A list of web resources

*) A summary of the chapters

*) A list of the key terms

*) An extensive set of exercises (no solutions provided)

*) A list of suggested programming projects

*) A list of suggested simulations

*) An extensive set of references

As befits the trends in computing, a great deal of time is spent on multiprocessing and distributed environments. Coded solutions to many of these problems are explained and Java is the language used to simulate the solutions. The last two chapters are case studies of the Linux and Windows XP operating systems.

At this time I am not teaching operating systems and do not know when I will teach it again. When I teach a class again after some time away from it, I generally make a list of my top three candidates for the text and select the one I consider the best. At this time, this book would be on that list of three.