Book Reviews

Practical File System Design with the Be File System

Great book that explains the basics and some advanced things about filesystems in general. But this book ALSO covers the BeOS filesystem (BFS). If your planning on making your own filesystem or are new to how a FS works: This is the book for you!
-rating: 10 reviewer: SPike

A TERRIFIC BOOK!!! This book is THE book to read if you are interested in making a file system, understanding the Be File System, or just understanding file systems in general. The author's writting style is very clean and easy to understand, yet it's not boring.
-rating: 10 reviewer: osmaker aka K.J.

This is a fine book. The title is a little misleading -- not only does it describe what the BeFS team went through when designing and implementing their file system, but also compares it with various other common file systems. This is the best benchmark for file system design.
-rating: 9 reviewer: Tim

Inside the Windows 95 File System

A good book, not so good a book... The title is somewhat misleading. I was expecting lots of info on the FAT file system. Hardly any at all is given in this book. Instead, this book focuses on how Windows 95 handles file system drivers, and how to make your own file system driver for Windows 95.
-rating: 5 reviewer: osmaker aka K.J.

MMURTL V1.0

I kinda hate to say this, but don't buy this book. The author's writting style is often hard to follow, and there are some errors throughout this book. There is some good stuff in it. But the price of the book and the small amount of good stuff doesn't begin to ballence out IMHO.
-rating: 2 reviewer: osmaker aka K.J.

This book is NOT giving the information you need to develop your own os. The book is full of source-code, which is also shipping on the CD. In my opinion he should take this space to explain the things he is talking about. Same as osmaker: You should not buy this version. Maybe a later one will be better.
-rating: 3 reviewer: Timo

For some odd reason I found this book slightly more interesting and witty than anyone here seems to think. I do have issues with it as well tho, namely the fact that it doesnt contain much good code and some of the descriptions are muddled to a rather unpleasant chunk of garble, but I found it interesting and found that it was handy to figure out kind of what you need to do, only you have to read the whole darn thing before you even get the basics. As I wrote this, at first my rating was a 7, but thinking about it, its a 5 :)
-rating: 5 reviewer: Akira

Very much agreed on the fact that the book itself is just the source code with some extra paragraphs explaining nothing useful. The OS itself is based on old concepts such as TSS, instead of context switching and has no support for Symmetric Multi-Processing. It only supports 4GB RAM I think, but there is a patch at the website. The system is very slow and runs only from floppy. Really the only part that I found somewhat useful text wise, was the part suggesting an order to writing your own. It also does not really explain HOW to create one, just explains theirs.
-rating: 2 reviewer: Craig

This book won't teach you how to write your own OS. Rather, it teaches you the way MMURTL does things. The book doesn't appear to have been proof read or corrected: it's full of grammar mistakes, lines are messy and unaligned, missing full stops, inconsistencies, etc. It's a really awful, amateurish job. That's sad because the author put an enormous amount of effort into this book and wrote the MMURTL system over five years. If he had've proof read the book, corrected all the obvious errors, and published professionally, then this book could have been a good general introduction to OSes (not writing your own though.) I've had this book for 18 months or longer, I can't remember how long I've had it exactly. I read the parts I wanted to read in an afternoon, and the rest was useless. I was still as confused as ever about where to start writing my own OS.
-rating: 1 reviewer: James

This book is something hefty and it resembles to be assembled and stuffed together in some hasty manner. Nevertheless, however bad it might be considered, it gave me a good start off. But only in company with andrew tanenbaums os-development book and with the undispensable hardware book. I had to do research myself. the authors canna tell one everything. What threw me up: the sloppy design and layout of the book and the fact that the os mmurtl itself isn't revised or under development anymore. Just coded down and that's it. You have to read exactly what stands written there and afteron you have to read between the lines to get the clue out of the sentences. Not very funny if one wants to learn something.
-rating: 6 reviewer: Thomas

Modern Operating Systems(2nd edition)

I found this book at my local libary and I must say it's pretty good. It has a nice introduction which covers some historical facts about various OS's and their designs. I like the structure as it's meant to teach you something (maybe because it's a textbook ;P). One downside is Andrew seems to assume you know at least a little about Unix and/or Linux (some consepts of these he covers so it's not a big problem).
Cheers, DH.
-rating: 10 reviewer: Dragon_Hilord

I've read most of this one, and it offers some quite in-depth information about Operating System Design. The only problem with it is that it's not a definitive guide to writing an OS, its just in depth coverage about OSes and what makes them work.
-rating: 9 reviewer: Jimferd

This book is excellent, a great insight into how the more popular operating systems work nowadays, and even includes references to older, but interesting systems. It weighs the merits of competing systems suprisingly fairly, and even includes a chapter on operating systems design, which is quite interesting. The only drawback comes for relatively new osdevers, the authors uses a few mathematical concepts that make it a little difficult to understand the algorithms.
-rating: 9 reviewer: Helio

Inside the Windows Nt File System

Distributed Systems: Principles and Paradigms

Operating Systems: Design and Implementation(2nd edition)

Very good book for those who really want to deal with the topic. But the book's to expensive for people who just want to develop their own "Fun-OS" However, a great book that explains really everything...
-rating: 9 reviewer: abless

Its good for operating system development in one sense, but sort of not in another. This book basically covers the operating system MINIX which is mini UNIX. Comes with source code which is at least commented. The main text dicusses theory mainly however, not writing your own.
-rating: 8 reviewer: Akira

The book is well written, in its own tech style (very straightforward) and, as mentioned before, is very comprehensive. The only beef that I have with the book is that the source is included at the very end of the book in order (aka not grouped with similar units, but in the same way a compiler goes through it) and references are made to line numbers through the text. The ideal way to handle this (IMHO) would be to dissect the code so a working example of how the things work, rather than having to flip back and forth and try to apply knowledge without its explanation on hand.
-rating: 8 reviewer: Wangpeng

This is the first book you should read if you want to write an OS. Here I assume you have mastered the C programming language and can at least read and "get the drift" of assembly language. You will need to know some of the very basics about Intel architecture processors before getting anything out of this book. Despite what you may think, this is not a beginner's book on OS development. This is serious stuff, but it's exremely well written. It is structured so that each chapter covers the general theory of one particular part of OS development (say, processes and IPC) then goes on to talk in great detail about the implementation of that particular topic in Minix. Minix is beautifully written, even though it is rather large for an educational OS (but well worth it, because let's face it, most of the time you get crap toy code at college.)
This book covers hardware topics beautifully, but not very thoroughly. It is geared towards understanding how an OS really works, not helping you to write your own. (In which case, a book would essentially have to be about programming hardware devices, details of processes and filesystems etc aside.)
This is sadly the only book I can recommend for writing your own OS. It is advanced, so you may like to read Silbershatz' book first (reviewed here, the book with the dinosours on the front cover.) As I mentioned you need a masterful command of C, a basic knowledge of 32-bit Intel/compatible CPUs and IBM PCs, and an understanding of assembly language.
After reading this and studying Minix, perhaps by ripping out device drivers and replacing them with your own (which is what I did, among other things), you need to study existing source code, especially Linux, Free/Net/OpenBSD, Mach/HURD and maybe FreeDOS and others too (Linux and BSD OSes are the most involved but worth the hard work.) Then you will want documents on standards like IBM PC I/O ports and "special" memory areas, SCSI, ATA/ATAPI, PCI, USB, etc... but if you want to just write an OS and not write your own device drivers first, you can always use OSKit (http://www.cs.utah.edu/flux/oskit). Basically OSKit is a "kit" for developing a new OS, with device drivers taken from Linux and FreeBSD etc, and you can even write a multiboot compliant kernel that says "Hello, World" in a couple of minutes and run it. You can gradually add your process model etc on top, then move it away from OSKit if you desire later on. Well, if you're not totally confused and insane by now ;) keep on at it, you WILL get there eventually. I've been at it for 3 years and I am not going to give up.
PS. Here's a tip: start with understanding the "big picture" like how a PC boots, e.g. for IBM PCs the BIOS, the MBR, the boot block, the bootstrap programme, the bootloader, enabling the A20 gate, switching to protected mode... etc. You get the drift.) Work from there. MicroC OS is in fact a beautiful example of a small real time kernel that has been ported more than 100 (!!!) times. You can download MicroC OS and the source code is included: everything you need to understand it in about 4 source code files (C and assembly) which can be read and understood in a few minutes (for an experienced programmer anyway, which I assume you are.)
Sorry for the diversion, but all up, after you have learnt C and at least some assembler and PC architecture, Tanenbaum's book here on Minix is the only serious contender in my opinion. Well worth it.
-rating: 10 reviewer: James

Excellent book, like the other reviews say. It gives all the needed information for planning an Operating System. One of the main downsides that I found was that the code was found in the back of the book, and not clumped in the concerning areas. Other then that, the book was a great buy. I recommend getting it at some Half-Priced book store, ebay, ubid, or half.com. I believe it is a better text book for college students / high school students then "For Fun". This book has a tramendous amount of data from other articles, books, etc. A well put-together resource. All in all, great book.
-rating: 9 reviewer: Kanzure

Indispensable Hardware Book

THIS IS A MUST-HAVE for anyone in the OSD (or computer science) sector! It contains everything you ever wanted to know about computers and their internals. I REALLY RECOMMEND THIS ONE!
-rating: 10 reviewer: SPike

A massive book with really really good contents. I think you can find almost everything that you look for about hardware interfacing and etc. Very formal and documentary lanuage, very informative a I think it is a MUST for especially hardware programmers. (But be warned, it is very thick)
-rating: 8 reviewer: Ozguxxx

Programming Pearls(2nd edition)

An excellent collection of essays on design and implementation in general. While it concentrates on 'programming in the small', it describes techniques that could be applied universally. Major topics include program testing and correctness, algorithmics, and optimization principles. This is a classic which should definitely be read by everyone.
-rating: 10 reviewer: Joseph Osako

A book which can help understand your programs better !. The main theme in this book is writing efficient code. It also includes discussions on correctness and algorithm design. A great book all in all.Make you think analytically about your progarms.
-rating: 7 reviewer: ravishankar

Just for Fun

Yesterday i bought JUST FOR FUN and one hour later I started reading. I read until I felt asleep. Today I continued and I'm done. This is one of the best biographies! (I rarely read biographies). You can have a look into the life of this Finnish genius; the book is very entertaining and has several jokings.
The book jumps a bit from the presence to the past but bit by bit you learn more and fly from his childhood further and further, you just can't stop reading. By the way, you have not to be a computer freak or a linux fan, apart from one section it's well understandable.
-rating: 10 reviewer: Stefan Zurfluh

This is one of the most entertaining "computer books" I`ve ever read. Describes how LINUX was developed but mentions no details. Excellent...
-rating: 1 reviewer: Hannes

First of: this book doesn't explain anything about OSD programming or so, this is a book about how Linus made Linux :) . Still this book is a great source of inspiration and contains "tips" (if you read between the lines) on how to successed with your OSD project.
-rating: 8 reviewer: SPike

I abselutely love this book. Im in the middle of reading it right now, and I can tell you that you wont want to put it down. I am not a big fan of biographies, as I tend to fare towards the Science Fiction/Fantasy aspect of things, but this is ungodly well written, and the most interesting thing I have read all year.
-rating: 10 reviewer: Akira

I read it and it was a very good book, it really motivated me to learn to program better so I could some day write the kind of code that Linus Torvolds did
-rating: 8 reviewer: microkid88

This is a wonderful and inspiring book for all programmers to read. it also has many details on how Linus developed Linux, it is awesome book to read...although I would like to see that code to that alternating A, B, A, B, program that Linus wrote when he tested protected mode, he documented the "Just for Fun" process in a fantastic way, i'm working on getting my own copy of it, but it's a must have if you are one of the "Just for Fun" people
-rating: 10 reviewer: pobetiger

I was glued to this book, its really great, I jumped straight in and started coding my kernel. Its good to get other programmers perspectives and their implementations, especially when its from the creator of the kernel we all just love.
-rating: 9 reviewer: Ecoine

Upgrading and Repairing PCs

Though slightly off-subject, in a sense, I found this book to be great. Most general knowledge questions can be answered using this. The definintion of boot processes, IRQs, interrupts, and such is stupendous. I must commend Mueler for his excellent work and would recommend the book to anyone who has ever seen a computer in their life. Well worth the $42.00 !
-rating: 10 reviewer: Akira

Operating System Concepts

A wonderful book , to get the basic hang of how an Operating System works. The chapter on IPC is not done very well, but the treatment for Memory Mgmt and File System Structures is laudable. Don't expect this book to guide you with the actual coding, Its far from hardcore. All in all, its an extremely readable and up-todate book.
-rating: 8 reviewer: Hareesh Nagarajan

This book is interesting, but once again doesnt actually tell you how to code. I also have been wondering what the dinosaur on the front has to do with anything.
-rating: 8 reviewer: Akira

It is a good text to start with, so that u get ur os concepts right. The initial bit is not so good. Once it moves into mem mgmt, virtual mem and filesystems, it gets pretty neat. No hardware stuff though. Just concepts. However, for the IPC and deadlocks bit, Modern Operating Systems - Andrew S. Tanenbaum may be good.
-rating: 7 reviewer: Rahul Iyer

Say you want to do something, like get some really basic paging going. Before you can program a page table or directory, you have to know what they are and how they fit into the overall operating system. To figure out what they are and how they fit, use this book. It's great - very little to no code. To figure out how to actually write the code - download a few open source OS's as guides, go through the Intel manuals, and consult Tanenbaum. OS Concepts pretty much follows it's name - it's a concept book, and a great one at that.
-rating: 8 reviewer: Simrook

Assembly Language Step-by-Step(2nd edition)

seriously, this is probably the worst x86asm book i have ever set my hands upon. Way back when i began to learn x86 asm, i picked this book up at the library, and spent some time standing there just flipping through the book. Duntemann talks to the reader as if he or she was a ignorant fool, cracking up pathetic jokes completely off the topic. It's not comprehensive, and most things are touched upon _very_ lightly. If memory serves correctly, there is about 1 or 2 chapters of so-called "programming with linux", in which the basic libc functions are explored.
if you just want to learn 16-bit x86 asm, i suggest you pick up kip irvine's SECOND (read SECOND, not FOURTH) edition, it has a purple cover, and the materials covered is quite decent, and suitable for beginners and intermediates (in the latter chapters, something along the lines of "advanced topics", i was suprised that it even partially covered the x86 instruction encodings, even with a skimpy length-disassembler engine!). The book, unfortunately, has a lot of typos, but you won't notice them unless you're a picky english reader. after you read kip's book about halfway, you can pretty much fend for yourself and skim the rest or keep the book as just a reference. and.. yes, i put back duntemann's book and got kip's instead.
your university library should have both (although the 2nd edition is somewhat out-of-print by now). hope this helps.
-rating: 1 reviewer: drocon

Before I write a word in my actual review, I would like you to know that this book is what I used to learn Assembly Language, and is practically the only knowledge I have on the subject other than looking at some code, so I might be a little biased towards this book. That said...
If you don't know x86 ASM, and would like to learn, look no further. This book covers how to program using NASM exceptionally. I had no previous knowledge of Assembly language, but I can now write some assembly applications, and this book has laid the foundation for me to further my knowledge in Assembly language. It also taught me a lot about computer basics. If you're an experienced Assembly programmer, though, you should probably skip this book.
I find it a very easy read, unlike some Assembly books you'll find. Learning Assembly language through a book could be intimidating for a novice, but this book makes it an easy task. Dunteman is a great writer, and teacher.
I like the layout quite a bit. It starts off very simple. It starts off by teaching you about number systems, in quite a creative way, and then moves on to teaching you about the basics of Computer Science. Once you have an understanding about that, he talks about NASM-IDE a bit, as that is what Dunteman reccomends using while programming assembly. He then goes on to talk about specific memory models. After that, you finally start learning Assembly language. You don't look at your first piece of code till about page 200 or so, but the things he discusses previous to that are required knowledge if you plan on understanding what's happening. He covers both flat and segmented model under DOS. All the basics of assembly language he does in this section. You learn lots of things. Basic instructions, (mov, xor, shl etc.) unconditional and conditional jumps, interrupts, loops, and so on. After that, you go into protected mode under Linux.You won't be an expert by the end of the book, but you'll be equipped to pick up on anything you don't know yet fairly easy.
All in all, great book. If you don't know Assembly, and would like to learn, pick this book up!
-rating: 9 reviewer: Mjordan2nd

This is a very good book for Novices to x86 Assembly language. Not one for the advanced Asm programmer tho. It covers 16bit programming in DOS (flat and segmented modes) and in this edition it now covers Asm programming in Linux. The book is very well thought out and structured, the first few chapters are on hex, binary and the hardware of the computer which is well worth knowing (but may be boring if you all ready know the subject the chapter covers) it has plenty of diagrams and helpful real life metaphors to get the points across and exercises if you fancy testing yourself (but it isn\'t based around the testing like some books). The middle of the book goes into using the DOS debug program (very useful at times) and then eventually DOS programming. This means you will need DOS but an old boot disk will probably do the trick. It covers all the basic principles and has left pretty much nothing uncovered. The end few chapters covers the GNU debugger and protected mode Asm in Linux.
Though this is a new addition in this edition it does cover quite a lot. The end of the book has a small refernce section but it is more of a guide while reading the book once you finsh the book you will want to grab one from the internet. The book has a CD with all the needed software on and examples (tho everything is opensource/freeware on the CD so you could manage without if you are getting the book second hand).
The annoying thing about the book is that in a couple of places it refernces to a non existance ASCII table appendix, but this is not a problem as you can get copys of the table online or in the back of other programming books.
This is not a refernce book (it doesn't just go through teaching you each command in turn) but a learning book teaching principles and assuming that you have no previous knowledge of programming. It may well not cover each command but gives you the skills to look up commands and understand them and put them into use.
If you are looking for a good and not to expensive Asm book so you can learn the basics and start working on your own projects (bootloaders and small kernels for example) this is for you. Once you finish the book you may need a couple more tutorials to advance your understanding and some refernce material but nothing major. So if the publishers add the missing refernce matieral and polish off an all ready amazing book it will get that extra point rating from me.
-rating: 9 reviewer: Daniel Faulkner

Linux Kernel Development

This book is akin to the "Design and Implementation" book by Tanenbaum. It is better than other linux kernel development books because a) it covers the new stuff (2.6), b) it includes lots of code examples and excerpts, and c) it is intended to be read rather than only referenced.
The book is written in a linear fashion (to steal a phrase from the intro); it's meant to be read from chapter 1 through to the end. It's a bit like a textbook in that sense. It's very readable, and it builds on concepts to help you understand the system in a way that can't really be done with just a technical reference processes & files are the fundamental things, the scheduler is built on processes, the VFS is built on files, and everything kind of flows from there with explanation of data structures and short sections of code along the way).
My only (and very minor) complaint is that there isn't much about device drivers, but there is some good documentation on the web for that (even for 2.6), and the O'Reiley books are good enough for most things.
This book is Linux specific, but covers enough design principles that you could learn a lot about OS stuff in general from it.
Two thumbs up.
-rating: 9 reviewer: aggieben