Customer Reviews

Operating Systems (The Systems Programming Series)

5 star:		(7)
4 star:		(2)
3 star:		(7)
2 star:		(0)
1 star:		(1)

 

 

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.

If you are a fan of the other Deitel books, you will probably like this one as well. I used this book in an undergraduate operating systems course and found it to be very useful. I later used the "dinosaurs" book (Silberschatz et al.) in a graduate course and was quite disappointed by the lack of detail.

One minor complaint is that this book is quite verbose, so one tends to get a little tired reading it. On the other hand, all of the details are what make this book a very good introductory text. My complaint about the "dinosaur" book is the lack of details and lack of verbosity.

In defense of the use of Java that other reviewers have complained about, I'm guessing that the writers wanted to use a language that their target audience (college undergrads) would most likely be familiar with. Also, using threads in Java is much easier than in some "OS-friendly" language like 'C'. As a way of demonstrating concepts, Java works quite well.

The content of this text is decent. However, the organization and display of the content is horrendous. Maybe the final editor of this book was blind and was going through a braille copy, I'm not sure. The typeface used for the headings and topics in this book are so awful they are literally distracting. There are headings in an "olde script" font face followed by subheadings in a modern cursive font face. Everything about it is over the top and tacky.

For some unknown reason, the publisher chose to set the table of contents, all the chapter headings, and all the section headings of this book in a cutesy cursive typeface -- in brown ink, no less. (If you squint, it looks a little like Tolkein's "elvish" writing.) This makes it very hard to find topics in the book. It even makes browsing the table of contents painful.

TO THE PUBLISHER: This is a reference book. It is NOT a novel. It should have been designed to make it easy to find things by browsing. It seems to be another case of modern textbooks favoring style over substance. Shame on you.

TO THE AUTHORS: Find another book designer for the next edition. As technical authors, your responsibility to your readers is to communicate information -- NOT to impress people with how cute your book looks.

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.

This is simply an awful book. The content is terrible and the design is worse. There are much better books available in this market with clear explanation, appropriate selection of topics, and from authors that actually work with OSs (the real author on this, Choffnes, doesn't semm to have any experience with OSs - research, practical or otherwise). This is not the way to learn this important topic. You would be much better off with the Silberschatz book, which I learned from and have taught from. Even Tannenbaum is a much better choice. Stay clear.

If your not an expert in computer science, or even if you are just a beginner, you'll find this book quite useful no matter the operating system you work with. This is also an entertaining book, since it can be read from the beginning to the end the same way you could do it with an exciting novel.
Concepts are explained very clearly and, if you'd like to go deeper in any topic, there's an extensive bibliography for every chapter. The document's structure is the same along the book, beginning with introductory text, an ending with a summary of concepts.
Don't be afraid if you're not a brilliant hacker. This book explains everything in such a friendly way, that it makes operating systems theory appear easier than other operating systems books do. Everybody can learn from it!

As many other reviewers have mentioned, this book has good content and very well written. However, the plethora of ancilliary information and cliche side-notes, mini-case-studies make what could've been a bar-non primer into a dreadful book. Even though I particularly think that OS is one of the bastions of computer science and thus I think it's a very interesting field, the authors totally missed their target audience insofar as design and layout is concerned! Additionally, this book is peculiar in that it tries to teach some OS examples using (of all possible languages) Java! What gives? Even my teacher (who usually defends this book) was upset about that one. And little by little the author manage to get a book you liked at the beginning of the semester into this horrendous text you don't even want to glance into. I gave three stars, because I do think that the content in the first five six chapters is really well explained and supported...overall...buy it if you must!

This was for me, a required college text and is likely the better of the two texts used for college courses on Operating System fundamentals. Coverage includes not only well illustrated textual explanations and explorations of those fundamentals, but sample code as well. It's a good text. It is one of two texts on the topic that I am aware of and I feel it is the better of the two, but that's a subjective opinion. It would be a worthwhile recommend to evaluate them both. The other book is Operating System Concepts by Silberschatz, Galvin and Gagne.

I used this book for an OS course i took at a community college. The subject matter is voluminous and the book covers it pretty well. I wish there were solutions to the many exercise problems. This will surely help in the learning process. Some authors/publishers provide additional resources on a student companion website. While the book does have such a site - the content is not very useful at all (just a bunch of ppt slides summarizing each chapter!).
Overall a great book. I learnt a lot about OS without much of a CS background