Customer Reviews

Operating System Concepts

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

 

 

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

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.

I used this book on my OS class in my MS in CS. I remember that back in college, I took OS with an older version of the same book, but now my perspective change drastically.

I you really want to take advantage of how an OS works and the techniques for managing resources and to apply this knowledge to your own programs, please read this book. If you like advanced topics such as multi-threading and multi-processing, it will help you to understand how the OS interacts with the user programs and how you can use different approaches such as thread kernel model, etc.

This book is VERY abstract. It's like learning a computer without actually having it. It tries to cover many concepts related to operating systems, but because of that no space left for a real life applications or examples. A simplest way they describe a process or a thread in this book is to draw a rectangle, name it process, draw another rectangle, name it CPU, put an arrow in between and you are done. And this is like that throughout the book and throughout all the concepts they are trying to explain. Very poor explanation and no examples at all. You will find challenging exercises at the end of each chapter, but you will not find any answers in the chapter itself. Each chapter simply gives you an idea about some operating system concept but how it actually work is up to you to figure it out. Text is very formal and hard to understand; they will confuse you even with simple concepts. I used to google many topics and found a much better and meaningful explanation online that I immediately understood and even taught others. Most of the projects are shortly described with little help on how to do it and no warnings if there is a chance on crashing a kernel, for example. I crashed mine, no big deal.

And don't expect to learn anything specific to UNIX or Windows, Solaris, or AIX, for example, as they do not go into that depth, only slightly they will cover how Windows handles that, how Solaris handles that.. blah.
Not worth of reading it, but had to have it as my textbook.

This book is written for a student who has some programming understanding. It's not absolutely necessary, but if you aren't familiar with programming concepts, you will have difficulty reading this book. For an entry-level Operating Systems class, it was a bit overkill, and went over the heads of most of my classmates.

Also note that the end-of-chapter Exercises in the International edition are NOT the same as the hardcover original. Not sure why they're different, but they are. I had to copy homework questions from my classmates' books for every chapter. The reading material is exactly the same, down to the page number, but the questions are different.

This is a very well written book on operating system design, multiprogramming, threads and all the great things that go on inside your computer while it runs an operating system. It requires some prerequisite knowledge of computer hardware and some programming. As other reviewers have stated, it is not a freshman level book. It is however, an excellent guide for people studying software design.

It seems to be lacking in some areas, the section on semaphores was probably the worse of the book. I had to turn to Tanenbaum's book for better information. Overall though, worthy of four stars.

Unfortunately, I have to add to my review that I am deeply disappointed in the direction the publisher has taken with respect to the text. I find it distasteful that publishers have gone from printing student solutions manuals to requiring access to a web site. Fortunately, the editions have not changed that much and the questions are still available in solutions manuals of prior editions or perhaps if you are lucky, someone has a PDF of them. Likewise, leading search engines can provide sources for researching the solution to see if your answer is correct.

This book was the required reading for one of my college programming courses. The authors go in to good details about the specifics of all subjects relating to operating systems in general. Some that were notable were the use and creation of semaphore objects, threading, CPU scheduling, and disk scheduling algorithms. The semaphores and threading were particularly useful in completing the classic synchronization problem 'The Dining Philosophers' which was one of the assignments for the course. The breakdown of disk organization was another very beneficial and highly interesting topic. The book covers MAC OS, Linux, Unix, Windows, as well as some information about older systems such as DOS and CP/M. The book has generalized examples and each topic includes a good deal of theory. I do not recommend this book for people without a solid foundation of C or C++. It helps to know Assembly as well, but not necessary.

I was careful to buy the US edition instead of the International edition. Despite the claims that the content is exactly the same, that is simply not true. The exercises after every chapter are different. One of my classmates unknowingly got the Int'l edition and was not so lucky. Entire sections of chapters were printed non-sequentially. In other words, the book had pgs 1-15, then 32-45, then 16-31. I've come to realize that the Int'l editions are the equivalent of Chinese knockoffs electronics for books. To use an old cliche: You get what you pay for.

The book itself does a good job of explaining each concept, although my professor's lectures clarified all of the confusing concepts. The writing is as interesting as can be for a topic I consider very dry. This edition is a bit outdated, using Windows XP as examples for many of the concepts. There is a more recent edition using Windows 7 called Operating Systems Concepts Essentials. Overall, if you are looking for a textbook introducing the design and inner functions of operating systems, I don't know of any better sources.

True to its name, this textbook focuses on the concepts and is at times very abstract, though it frequently discusses how different real OSs (Windows, Mac OSX, Solaris) tackle different OS design problems.

I thought the material was at the perfect level of detail for me, an application programmer. One of the most readable textbooks I've had in my four years as a computer science undergrad. Easy to understand and end-of-chapter summaries were a welcome addition.

This book provides a ton of information, but it is extremely difficult to navigate. Important points are not made explicitly, and the reader is forced to unravel the obscure thought process of the many authors to weed out salient information. This book makes no attempt at providing a functional and practical understanding of the topics discussed.