A wonderful contribution: Modern Operating Systems by Andrew S. Tanenbaum.

His book, "Modern Operating Systems", is a fascinating read for any geek. He discusses MINIX a fair bit (unsurprisingly!)

I feel like Minix is underappreciated. I'm reading Tannenbaum's Modern Operating Systems at the moment and he makes a persuasive appeal for some of its unique takes of the *nix OS family.

My favourite intro to threads is just the Modern Operating Systems text. Fantastic author

> Tanenbaum's Modern Operating Systems

I found Operating Systems: Three Easy Pieces to be better.

http://pages.cs.wisc.edu/~remzi/OSTEP/

Virtual memory is part of the fields of computer architecture and operating systems; popular textbooks are Computer Architecture: A Quantitative Approach and Modern Operating Systems.

http://books.google.com/books?id=pqYl3SWkA64C
http://books.google.com/books?id=tqtZGQAACAAJ

Modern Operating Systems by Tanenbaum, although it's more basics, still relevant for low-level stuff.

Some books I learnt off and still seem to be around

Modern Operating Systems by Tanenbaum is a good theory book - this will probably answer your questions about flushing etc

for down and dirty:

Advanced Programming in the UNIX Environment

TCP/IP Illustrated, Volume 1 (2 and 3)

Nice choice.

I would add: An Introduction to Database Systems - Date

Also a few unmentioned so far:
Discrete Mathematical Structures - Kolman

Introduction To Systems Analysis And Design - Hawryszkiewycz

Modern Operating Systems - Tanenbaum

Pick up Discrete Mathematics by Knuth, Foundations of Mathematics by Sibley, Modern Operating Systems by Tanenbaum, and Computer Organization and Design by Patterson and Hennessy.

You internalize those, combined with your experience, and you'll be better off than a lot of CS grads.

As a comprehensive textbook on operating systems I would recommend reading "Modern Operating Systems" by Andrew S. Tanenbaum.

Yes, it's almost a 1000 pages, but it's written very accessibly and understandably.

Not very Linux specific but Tanenbaum's "Modern Operating Systems" is an excellent source for OS theory and very readable as well. It's an expensive book, but I found it worth its money.

Hm I have Modern Operating Systems and Solaris Internals somewhere here I'd be willing to put up also. (Hard to part with McKusick's fbsd book..) I'm definitely going to add a bunch tonight.

For a comprehensive book on the theory behind operating systems I can recommend "Modern Operating Systems" by Andrew S. Tanenbaum.

It does not focus on the concrete implementation of an OS though.

Modern Operating Systems - The classic dinosaur book from Tanenbaum.

Wrong.

The dinosaur book is written by Silberschatz, Galvin and Gagne and is called "Operating System Concepts"

Structure and Interpretation of Computer Programs (), Introduction to Automata Theory, Languages and Computation (Hopcroft Ullman), don knuth's art of computer programming, Tanenbaum's Modern Operating Systems, Compilers: Principles, Techniques, and Tools5 (Aho Sethi Ullman)

Yeah it's basically an Operating Systems book like Tanenbaum's "Modern Operating Systems".

Probably not what you are looking for, but I can wholeheartedly recommend "Modern Operating Systems" by Andrew Tanenbaum. Yes, it is a whole book, and it goes to quite a level of detail, as you can imagine, but it is written really nicely and engaging.

If you don't want the full level of detail, just skip certain parts! You will still learn a lot. I know many people are reluctant to "read a book" and then skip 80% of it, but it is a really great technique for non-fiction.

Read Modern Operating Systems by Andrew Tanenbaum. He builds an Operating Systems from scratch in the book.

Yes.
I'd also get 'Modern Operating Systems' by Tannenbaum, which will explain lots of stuff that might be opaque/confusing if you're not already a kernel guy.

Modern Operating Systems by Tanenbaum, perhaps?

Here is the table of contents: http://www.amazon.com/review/R3K8J39AMWS64U/ref=cm_cr_dp_tit...

Modern Operating Systems by Tanenbaum

One book many engineers have cut their teeth on for OS would be Andrew Tanenbaum's Modern Operating Systems, 3rd ed.

http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenb...

I thought he did that with the Minix book not Modern Operating Systems?

To GP: Modern Operating Systems[1] is taught in almost every CS program in the world. It covers a lot of the topics needed. It might be a bit dated but has a solid foundation.

[1] https://www.goodreads.com/book/show/166195.Modern_Operating_...

I just wanted to add that I felt Tanenbaum's Modern Operating Systems was a tad light on some of the core topics (especially when trying to get a good grip on the issues behind concurrency). I personally recommend the book by Silberschatz: http://www.amazon.com/Operating-System-Concepts-Abraham-Silb...

I also think for understanding how operating systems work, nothing beats writing your own! I learned most of the concepts by building a toy OS during the better part of my undergraduate studies. I highly recommend this for people who like coding and are afraid of jumping into the theory too quickly. For example, analyzing memory allocation algorithms is never as interesting as when you have to pick one for your own kernel!

I love this list, and would love to see an updated list so I can add the recommendations to my reading list :)

Have you ever checked out OSTEP: Three Easy Pieces? (http://pages.cs.wisc.edu/~remzi/OSTEP/) I am finding that a much more accessible, organized, and easy-to-ready resource than Tanenbaum's Modern Operating Systems. What do you think of it?

Also, I've recently got my hands on "Practical Filesystem Design," written by the developer of the BeOS filesystem. A PDF is available here: http://www.nobius.org/dbg/practical-file-system-design.pdf

You seem like a really nice person with similar interests as me, I'd love to actually get to know you :)

I started out with C, definitely didn't know how to write multithreaded code when I was 10 haha. I learned most of that after reading a great book on operating systems (Modern Operating Systems by Andrew S. Tanenbaum) a couple months ago.

I'm trying to clean up my Github, you'll notice the "DayN" repositories are just edited versions of stuff I found online to learn from. These days I create my own projects, and am slowly deleting those "learning" repositories and making them private.

Thank you for sharing this list of OS dev resources!

I would also recommend Andrew Tanenbaum's "Modern Operating Systems" or "Operating Systems: Design and Implementation" (the MINIX book), to anyone interested in OS dev. I read it when I was teenager (around 15), and I really really enjoyed it. Tanenbaums' books were one of the few truly addicting textbooks. As a side, "Structured Computer Organization" by Tanenbaum was also really great. It gives you a foundational understanding of how computers are architected that is indispensable if you're going to be doing OS dev.

This is one of the guys that i have learned a lot from.
Even though i have never seen him nor have i ever met him.

But his words still echo in my mind. Modern Operating Systems and Computer Networks , both extremely well written. They certainly did taught me alot.

Here is to Prof. Tanenbaum , Thank you sir , for teaching me .Even though i've never met you nor i may ever meet you in this life but you should know that some guy from South Asia is thanking you from the bottom of his heart.

You just caught me at a moment where I'm reading Tanenbaum's book on Modern Operating Systems. Tanenbaum simplifies a lot of things, but here is his contribution [1]:

> The second development concerned the language in which UNIX was written. By now it was becoming painfully obvious that having to rewrite the entire system for each new machine was no fun at all [0], so Thompson decided to rewrite UNIX in a high-level language of his own design, called B. B was a simplified form of BCPL (which itself was a simplified form of CPL, which, like PL/I, never worked). Due to weaknesses in B, primarily lack of structures, this attempt was not successful. Ritchie then designed a successor to B, (naturally) called C, and wrote an excellent compiler for it. Working together, Thompson and Ritchie rewrote UNIX in C. C was the right language at the right time and has dominated system programming ever since.

Tanenbaum doesn't say it, but it almost seems like B and C were designed for creating UNIX. I wonder to what extent the authors of B and C were designing the languages for creating UNIX.

[0] In one of the previous paragraphs, Tanenbaum mentioned that the first version of UNIX was written in assembly.

[1] Modern Operating Systems (ed. 4, p. 715)

While the tone of the parent is a bit, well, it could be better :) I do think the parent has a point. For example, I just finished reading Modern Operating Systems by Tanenbaum. His experience shows. This form of experience cannot be showcased by someone who's learning or just has learned a particular technology. And I know I'm taking one of the giants as an example, and they show this particular example in its most extreme form.

With that said, I have read/watched tutorials by people who just learned something and the empathy level to beginners is really high. That's something that can be missing with people who have years and years of experience.

I can second the recommendation of Robert Love's books on Linux (https://rlove.org/) as well as "How Linux Works" by Brian Ward. I personally enjoyed "Linux Kernel Development" by Robert Love more than the former as it teaches you more about Kernel internals (IMHO). The drawback is that it's a bit outdated already (it's based on the 2.6 kernel) but on the other hand most things are still relevant as far as I know. Andrew Tanenbaum et. al.'s "Modern Operating Systems" is a good reference to learn about operating systems otherwise, independent of Linux.

Circa 1999 I studied Minix in a operating design course, but in the same way we studied Amoeba or Mach; in fact we used a pre 1.0 Linux kernel for practice (I don't remember the distro, it could be custom), and it was small enough to understand the different parts, hack, compile and run.

"Operating Systems: Design and Implementation" (included Minix) and "Modern Operating Systems" are great books and I think is because of them that Minix is relevant in OS teaching (specially OSDI, although I enjoyed MOS too).

EDIT: typo

First edition was a great book. For anyone interested in other OS dev books, I highly recommend:

  - Design and Implementation of the UNIX Operating System (Maurice J. Bach)
  - Modern Operating Systems (Andrew S. Tanenbaum)
  - Operating Systems Design and Implementation (Andrew S. Tanenbaum)
  - Linux Core Kernel Commentary (Scott Andrew Maxwell)

+The Practice of Programming - K&P are prolific authors and deliver the salient points of a BSCS and the transition into practicing programmer. Best bang for your buck.

+Code Complete - A no nonsense approach to Software Engineering and other tasks related to development. The SE texts used in most college courses are far too advanced and abstract for undergrad students that have never worked on very large projects. This one delivers excellent advice for single programmers up through medium size groups.

+Some algorithm and data structure book - there are a lot of bad ones. Use Amazon ratings to try and find a good one. Work through the design of as many algorithms as possible, no matter how mundane or the fact that most practical languages have libraries that deliver this functionality. Know what algorithmic complexity is and memorize the complexities of often used data structures to help quickly choose while coding.

+An operating system design book (e.g. Operating System Concepts or Modern Operating Systems) - know how the OS packages RAM, storage, CPU scheduling, network, concurrency for userland programming.

I have spent a lot of time taking online courses. Here are my favorites.

CS50 (https://www.edx.org/course/cs50s-introduction-computer-scien...) - Best Intro to Computer Science

Nand2Tetris I and II (https://www.coursera.org/learn/build-a-computer) - Build a computer from logic gates up to a compiler, this is the best class I've ever taken.

Agile Development Using Ruby on Rails (https://www.edx.org/professional-certificate/agile-developme...) - Great introduction to web development and software engineering principles

I've also been reading some technical books. Would definitely recommend

Modern Operating Systems - Tanenbaum
Designing Data-Intensive Applications - Kleppmann

Operating Systems: Design and Implementation, the Minix book that is sort of famous for inspiring Linus Torvalds, is more targeted at those who want to move into OS development.

Modern Operating Systems is an amazing book but it works at a somewhat higher level. You'll basically read about stuff that happens, or might happen, in an operating system. You'll learn about threading, the elevator algorithm, dining philosophers, how virtual memory works, how a memory allocator works, and a bunch of other stuff.

It's a very well written textbook. The thing that struck me was the way it introduces things at a theoretical or high level and then trusts students enough to present them with real C code and real problems to solve on the next page. Just an excellent textbook.

I don't know but the Tanenbaum books."Operating Systems Design and Implementation" is old, but the appendix is the full C source code to Minix 3.0 if you buy the 3rd Edition.
I had the 1st Edition with around 12K lines of C in the appendix. Great book, and I had Minix 1.5 running on my old Amiga around 1990. Minix was more portable than Linux, which came out around 4 year after Minix.
I had my money on Minix when Linux came along, since Minix was a microkernel, and I thought it sounded like the better direction to take. Well, Linux won out, and funny enough microkernels came back in style anyway with MachTen, MkLinux, and QNX. QNX was very successful in the realtime OS world. I used it on two jobs.
The newer Tanenbaum book: "Modern Operating Systems" I have not read, but if it is like the first one, I'd imagine it would be very educational too.

This response is late that I doubt will even be read by the poster, but I will throw this out there anyway.

I was (am?) a self-taught programmer, I guess I am transitioning away of that label. I am a bit less than halfway through the MSCS program at the moment. I really cannot recommend it enough.

I think I was a pretty good software engineer prior to getting some formal education, but I cannot tell you how often in class the light from heaven just shines right down.. "oh so that's why x is y". If you enjoy the work, its a real pleasure (albeit a painful amount of work at times).

So finally I get to the point. I can see that you have already received a lot of good recommendations. I think most of them are quite good. However, I have a couple of observations about specific books.

Intro to Algorithms - Cormen etc.
If you feel you need a discrete math course, then this book is probably not a good place to start with algorithms. It is a rigorous treatment of the subject. However, if you lack mathematical sophistication, this book can be tough. I aced my discrete course prior to taking an algorithms course taught with this book, and I struggled mightily to get an A-. I found the proofs in the book difficult to understand on many occasions.

Modern Operating Systems - Tannenbaum
This book is very easy to understand and provided me with so many "A HA!" moments. A real pleasure. I am not sure what your current work is, but the only pre-req on this book is a modest amount of C/C++ programming. The reason I say this is because I found that having that, this book allowed me to finally understand what is happening from compile time down to the CPU at runtime. A really rewarding journey.

Another interesting rabbit hole to explore is the compiler. Back in the day I wrote a toy compiler for a college course and used this text book: "Compilers: Principles, Techniques, and Tools". a.ka. "The Dragon book", but I would look at some of the other books here like "Modern Operating Systems" before this.

"Windows Internals" 7th ed. part 1 and 2 by Mark Russinovich would be the definitive current reference on how Windows itself works but assumes knowledge of how operating systems in general work already.

For general OS knowledge, I second the other poster's recommendation of Tanenbaum's "Modern Operating Systems"

what programming languages do you teach? I ask because, I remember now back to when I first really started trying to program, and I think it would have been great to get introduced to interesting code bases back then. So guess, I'm just looking back now and will recommend what I wish I had had, maybe some of it help:)

As a teen, I fumbled around for a while before discovering linux and open source and that good feeling you get when you download the src and start perusing and firing up your debugger. Having said that if you teach js, I'd highly recommend dojo, underscore, I guess most c /c++ might be too advanced but if not Webkit, Redis, and glib are clean fun code bases and dissecting Lisp / Emacs was a blast. As far as answering you actual question goes, I really liked Gödel, Escher, Bach back then, also thinking recursively by Roberts. The only "technical" book I enjoyed reading was Modern Operating Systems by Tanenbaum ( don't know what current editions are like, the roughly 2000-2001 version was great though). Its was simple, very clear, humorous, and a gives a great overview of how the os works.

There's a good chance I have read more of his work than you have.

Yes, Dijkstra made major contributions to algorithms—exactly the "safe corner" where correctness thinking applies. Ironically, one of his contributions was to the concept of semaphores. I sure don't hear any of Dijkstra's fans claim today that if distributed programs just used semaphores, all our concurrency problems would be solved.

Another important contribution: The Banker's algorithm, of which Andrew Tanenbaum observed (Modern Operating Systems, 2nd ed):

> The banker’s algorithm was first published by Dijkstra in 1965. Since that time, nearly every book on operating systems has described it in detail. Innumerable papers have been written about various aspects of it. Unfortunately, few authors have had the audacity to point out that although in theory the algorithm is wonderful, in practice it is essentially useless because processes rarely know in advance what their maximum resource needs will be. In addition, the number of processes is not fixed, but dynamically varying as new users log in and out. Furthermore, resources that were thought to be available can suddenly vanish (tape drives can break). Thus in practice, few, if any, existing systems use the banker’s algorithm for avoiding deadlocks.

... which is pretty much my argument: Dijkstra picked himself the neat little corner that WAS amenable to mathematical reasoning, at the expense of real world applicability.

One of Dijkstra's contributions to language design was resigning from the Algol 68 committee. It might do proponents of formal methods good to reflect on why that language was less than a stellar success, given how strongly it relied on advanced formal descriptions.

But the question is not whether Dijkstra contributed to algorithms, language design, or concurrent+distributed computing (he certainly did). The thesis that the Article presents (and supports by quoting Dijkstra, who did agree with that thesis) is that formal methods apply universally in system design, and that today's software woes are largely the result of insufficient application of formal methods.

It is there that I disagree, and that Dijkstra kept pontificating about despite having abolished programming and using computers around the time he started focusing on formal methods. And that detachment from and disdain of the actual practice of computer use is what renders his later opinions suspect to me.

I can't really emphasize enough how well-written his books are. I picked up some of Tanenbaum's books early in high school (specifically: Structured Computer Organization, Modern Operating Systems, and Computer Networks). They were so well-written and engaging they I could hardly take my eyes off of 'em. They really cultivated an interest and love for Computer Science in me.

I have the Hillegass book (he is a friend of mine).

I have:
- Modern Operating Systems
- Operating Systems Concepts
- Operating Systems (Design and Implementation)
- Solaris Internals
- Design of the FreeBSD Operating System

Sorry for being vague. I just dont have them in front of me right this second...but I cab get more specific if you want.

I shall refer to a higher authority:

> A set of processes is deadlocked if each process in the set is waiting for an event that only another process in the set can cause.

That is from Modern Operating Systems, 4th ed. (2015), by A.S. Tanenbaum & H. Bos, page 439. (By "process" they really mean "process or thread".)

One way for thread A to wait on thread B is as you said: thread A can request a lock that thread B currently owns; then A waits for B. So requesting locks in opposite orders can result in deadlock. But of course if there are no locks, then no such waiting occurs, and so deadlock from this cause is impossible.

But there are other ways to wait. If var_a and var_b are shared variables, then code like the following might result in deadlock (The following code is in C; to simplify things, I'm assuming that data races and memory-access ordering are not issues.)

Thread A does:

    var_a = 1;
    while (var_b != 0) ;
    var_a = 0;

And thread B does:

    var_b = 1;
    while (var_a != 0) ;
    var_b = 0;

If Pony is capable of executing code like the above, then deadlock is possible.

The crash seems to be in CoreText. CoreText is embedded/linked in Messages, Spotlight, Springboard, etc. CoreText is written in C.

The fix would be to rewrite CoreText in a memory safe language like Swift. This would be “hard”. Or put CoreText in an XPC container. This would both be “hard” and result in terrible performance.

For more details on how hard C, memory management, systems programming, and operating system development is please refer to your local copy of Modern Operating Systems by Andy Tannenbaum.

I have always felt I have not really understood things from the bottom up in terms of CS- like how do we really get from bits to software? I have been building Ben Eater's 6502 computer, which has been mostly enjoyable (cutting/stripping wires and getting them into the exact right small little hole is tedious at best, hurts my back at worst).

I have also been reading Modern Operating Systems by Tanenbaum- though a quite old edition from the early 200s- wondering if its worth putting on hold until I can get my hands on a newer edition.

Next up, I'd like to do Ben Eater's 8 bit computer as well as nand2tetris.

Well, for nerd books, "Modern Operating Systems" by Andrew Andrew Tanenbaum. It was until years later that I realized just how much I had learned from that book, and the consolidated notes from the Usenet flame war between him and Linus Torvalds.

There's just so much "how does all this shit actually work" in there ....

start off with reading 1) linux kernel development 2) linux device drivers 3) linux kernel module programming guide

have - understanding the linux kernel as your reference manual.

by now, you should be comfortable to read/understand the kernel source; download linux kernel source and start browsing through the code.

simply reading books wont get you anywhere - you need to play around with kernel source inorder to understand the linux kernel behavior and different problems you may come across. write simple kernel modules to get a hang of how you can interact/modify with the kernel.

join some opensource project and start fixing bugs you're comfortable with or just play around with your local linux kernel source - make changes; build and deploy and observe what happens.

EDIT:

if you have no prior knowledge of OS Theory and Fundamentals; then you should start here first - read either of the following books
1) Operating System Concepts by Galvin, Silberschatz OR 2)Modern Operating Systems by Tanenbaum

For programming related - system calls and stuff
read 1) Advanced Programming in the UNIX Environment - by Richard Stevens

> Similarly for your "kernel preemption. A blocking mutex and a spinlock". Again I can guess, but I doubt that your terminology is both well defined and common.

Really? That's standard terminology and I could define both in few sentences and could fresh out of college. I don't do OS development (and while I've tweaked a few lines in the kernel source, I'm not a kernel hacker by any means), but I understand the differences between spinlocks, event loops and blocking on mutexes (it's a core part of userland systems/network programming).

I highly suggest picking up Andy Tannenbaum's "Modern Operating Systems" (the MINIX book is excellent too, but is more about "the right way" to build an OS with a microkernel etc... rather than a case study of what exists). It's accessible and meant as an undergraduate text and will give you at least a cursory overview of these issues. It just seems like you had a bad professor for your operating systems course.

It really depends on what you feel you're missing and what you're hoping to do (definitions of "daily work" vary widely). If you're looking to get up on theory by doing your own program of sorts, you could do worse than start with these (in roughly this order):

Structure and Interpretation of Computer Programs - Abelson, Sussman, and Sussman

Introduction to Algorithms - Cormen, Leiserson, Rivest, and Stein

The Art of Assembly Language - Hyde

a digital logic book (not sure which is most recommended), and an architecture book (see reply by tftfmacedo)

Modern Operating Systems - Tanenbaum

Introduction to the Theory of Computation - Sipser

Compilers: Principles, Techniques, and Tools - Aho, Lam, Sethi, and Ullman (a.k.a. "Dragon Book")

Programming Language Pragmatics - Scott

A database design book (one that covers Relational Algebra, not just a book on SQL), and maybe a book on Networks. Also, Roy Fielding's paper on REST is both academic and applicable (and more approachable than you'd expect of a Ph.D paper). If you want to go all the way, an undergraduate program usually also has Calculus, Discrete Math, Linear Algebra, and Statistics. Some schools would also require Physics and Differential Equations. I'm sure I'm missing some topics, too, particularly electives.

If you can get through those and the associated problem sets, you'll have a better foundation than most.

I'll second the Algorithm Design book recommendation. An even better theory book is Introduction to the Theory of Computation by Sipser, however it covers slightly different topics. It is one of the most readable theory books I've seen, highly recommended, and a great resource for information on regular languages, context-free grammars and turing machines.

A less theoretical book, that is useful for a gentle intro is Masting Algorithms with C.

A bit off the theory track, but useful for a software engineer: Modern Operating Systems by Tanenbaum and Computer Organization and Design for info on hardware.