Reddit mentions of Operating Systems Design and Implementation (3rd Edition)

Thank you all for your responses! I have compiled a list of books mentioned by at least three different people below. Since some books have abbreviations (SICP) or colloquial names (Dragon Book), not to mention the occasional omission of a starting "a" or "the" this was done by hand and as a result it may contain errors.

edit: This list is now books mentioned by at least three people (was two) and contains posts up to icepack's.

edit: Updated with links to Amazon.com. These are not affiliate - Amazon was picked because they provide the most uniform way to compare books.

edit: Updated up to redline6561

• 14 The C Programming Language
  
• 11 Structure and Interpretation of Computer Programs
  
• 8 Introduction to Algorithms
  
• 7 Compilers: Principles, Techniques and Tools
  
• 6 Programming Erlang
  
• 5 The Mythical Man-Month
  
• 5 The Pragmatic Programmer
  
• 5 Applied Cryptography
  
• 4 Beautiful Code
  
• 4 The Little Schemer
  
• 4 Programming Perl
  
• 3 Types and Programming Languages
  
• 3 Gödel, Escher, Bach
  
• 3 OpenGL Programming Guide
  
• 3 Code Complete
  
• 3 Artificial Intelligence: A Modern Approach
  
• 3 Programming Pearls
  
• 3 ANSI Common Lisp
  
• 3 A Brief History of Time
  
• 3 Agile Web Development with Rails
  
• 3 Concrete Mathematics: A Foundation for Computer Science
  
• 3 Modern Operating Systems
  
• 3 Paradigms of Artificial Intelligence Programming
  
• 3 Operating System Design and Implementation
  
  

You need to show that you know your stuff. Just because you're doing something more applied like Network Security in grad school doesn't mean that you won't have a base level of knowledge you're expected to understand. In that case, you need to learn some basic stuff a CS student at a good school would know. I'm not "dumbing down" anything on my list here, so if it seems hard, don't get discouraged. I'm just trying to cut the bullshit and help you. (:

• Redo your introduction to Computer Science. If you finish this, picking up a new language is cake.
  
  
• Discrete Mathematics, A.K.A. "Math for Computer Scientists" This is the standard text for this, but this is pretty good for a cheap book.
  
  
• Algorithms
  
  
• Compilers
  
  
• Operating Systems
  
  
• Networking
  
  
• For basic CS theory, "Introduction to Theory of Computation by Michael Sipser" is what I used to recommend, but Amazon doesn't seem to have a sanely priced copy. Either buy that used, or get the classic "Cinderella Book". Get an older edition if you can!
  
  Again, don't be discouraged, but you'll need to work hard to catch up. If you were trying for something like mathematics or physics while doing this, I'd call you batshit insane. You may be able to pull it off with CS though (at least for what you want to study). Make no mistake: getting through all these books I posted on your own is hard. Even if you do, it might be the case that still no one will admit you! But if you do it, and you can retain and flaunt your knowledge to a sympathetic professor, you might be surprised.
  
  Best of luck, and post if you need more clarification. As a side note, follow along here as well.
  
  Netsec people feel free to give suggestions as well.

Firstly, you should pick up a text on Operating Systems. There's a few classics:

• Silbershatz's Operating System Concepts (aka "The Dinosaur Book")
  
• Andrew Tanenbaum's Operating System Design and Implementation (aka "The Minix Book")
  
  That being said, the summarized version (assuming we're talking about pre-emptive multitasking) is that shortly after the OS boots, it initializes the hardware timer with some delay value (1ms is common in modern OS's, but others aren't unheard of). When the hardware timer expires, it issues an interrupt. When a hardware interrupt occurs, the processor will push the instruction pointer, stack pointer, flag registers (and perhaps others) onto the stack and begins executing the code at the address configured for the interrupt.
  
  An OS will have installed an interrupt handler for the timer that will run the task scheduler. In a really simple model, the task scheduler will suspend the currently running task by copying the various registers (flags, instruction pointer, stack pointer, etc) from the stack into memory. It will then select the next task that it wishes to execute and copy its registers onto the stack (replacing what was pushed there initially by the timer interrupt). Finally, it will reset the timer for another delay and will issue an "interrupt return" instruction which will pop the saved-registers off the stack and back into their corresponding locations in the CPU registers. At this point, the previous task is suspended, the new task is running.
  
  If you're feeling adventurous and have access to a microprocessor which has a timer and hardware interrupt support, you can write a fairly simple/naive scheduler yourself with relative ease (I did this on a Motorola HC12 in university for fun).
  
  In practice, a modern OS has a bit more to deal with than just the CPU registers. There might also be a virtual memory sub-system which needs to be updated, many other registers beyond just the IP, SP and flags which need to be saved and restored, etc. Additionally, many OS's have potential complex algorithms to select which task to run based on a variety of considerations: is the task interactive or doing batch work, are we trying to meet real-time scheduling requirements, is there an affinity to a particular CPU core that we want to consider (perhaps there's L2 cache that we like the application to stay close to), etc.
  
  In short: the PC isn't nulled out, it's saved away and then eventually restored.
  
  There's a whole other discussion which could be had about other types of multi-tasking. Co-operative multitasking was common until the mid-90s (System 7 on the Mac was co-operative, for example). In this model, applications need to periodically release control to the operating system. This is done through a system-call (and thus a software interrupt); in the case of the mac, this was WaitNextEvent.

This and this by Tanenbaum are the best books on the topic i have read until now.

If you want to learn about OS, check out MINIX. It's a UNIX-compatible OS specifically written for educational purposes. What makes it really great is that there's a book, Operating Systems: Design and Implementation, which describes the OS in detail and comes with the annotated source.

OS Design. Covers the creation of MINIX, the jumping point for linux. This is the 3rd edition of the book that came out way back when.

....just noticed they want 100 bucks for it.

edit: Link to minix3 site.

I like Operating Systems: Design and Implementation. It walks through the MINIX3 micro kernel. It is not a tutorial or a step by step guide, but I think it gives a very nice foundation of what it takes to make a functioning kernel.

It goes without saying, I'm sure you already have it if you're working on a project like this already...

Anyone interested in building an OS for the dcpu16 should own a copy of this book.

Operating Systems, Design and Implementation http://www.amazon.com/Operating-Systems-Implementation-Prentice-Software/dp/0131429388/ref=pd_sim_b_5 the book has full examples, and if you wanted the OS printed, is at the end of the Book, also comes with a CD that has the OS compiled and ready to run.

Since you know Java I would suggest that you a read one of the best programming books ever written: [K&R The C Programming language] (http://www.amazon.com/The-Programming-Language-Brian-Kernighan/dp/0131103628/), this book was written by the people who made the C language and it's one of the best books ever written. It is a must read for every C programmer. [Computer Systems: A Programmer's Perspective (3rd Edition)] (http://www.amazon.com/Computer-Systems-Programmers-Perspective-Edition/dp/013409266X/) is a great book to learn about computer systems. But I would recommend [Operating Systems Design and Implementation (3rd Edition)] (http://www.amazon.com/Operating-Systems-Design-Implementation-Edition/dp/0131429388) because it has some minix source code which will go really well with learning C.

Best of luck buddy :)

An old, old Unix thing (if you're interested in that stuff, the book _Lion's Commentary on Unix_ is awesome, and so is the Minix book, _Operating System Design Principles_ or something like that... _Operating Systems Design and Implementation_ ... Google knows exactly what "the Minix book" is =P)...

Unix is a pre-emptively multitasking OS. Cooperative multitasking OSes are thankfully extinct or nearly. Those would wait until a process decided that it was done with the CPU and gave the CPU back to the OS before changing tasks. That includes changing tasks between the database app running and the user interface that handles mouse movements and keyboard processes and clicks such as clicks to just close the damn thing. Pretty clearly that would allow any badly written program to wedge the whole computer, except instead of "badly written", "not extremely well written". It's doomed to fail.

So Unix fires off an interrupt several times per second, such 100 (that's the tick and the tick frequency) that interrupts the program and runs the OS task scheduler. The OS task scheduler looks to see if there is anything else of the same or higher priority that also needs to run, and if so, pauses the currently running task and fires up the other one that needs to run. That's called a context switch. That keeps the system responsive and multitasking. You could have 100 tasks waiting for CPU and all of them will get some CPU every second.

But that wasn't designed for laptops running on battery that only have a few tasks. This interrupt runs 100 times a second even if no tasks are waiting for CPU (maybe X is waiting for input events... and waiting for input/output is part of this system I've ignored). The CPU would ideally be in a snooze state taking very little power, but this keeps waking it up.

Ticks also help the OS keep time, compute internal stats such as how much data is being transferred in a time period, how many processes are waiting for the CPU, etc. Stats are updated each time this timer interrupt goes off.

"Tickless" systems on the other hand don't interrupt or wake up the CPU at any fixed interval. If it wakes up the CPU once and discovered that no tasks are waiting for the CPU, it won't wake it up again for a long time. Input events including the touchpad and network and disk also generate interrupts which wake up the CPU so that is okay.

Also, the timer to change context (move from one waiting process to the next) can be higher or lower. If only two tasks want CPU, it can change context less often, or if a thousand tasks are waiting and processing would otherwise be locking out the UI, it can change tasks more often by deciding that the next task change will be in 0.001 seconds instead of 0.01.

This is the knowledge required to create the kernel. It probably doesn't go into the UI.

An excellent and surprisingly complete book describing many lower level concepts would be Operating Systems: Design and Implementation (3rd ed. 2006) by Andrew Tanenbaum. It is about writing your own Linux-type OS called Minix complete with memory management, locks, scheduling, quantums, so much more. Even if not creating an OS the algorithms and hardware details it can teach you are bricks of gold for any programmer.

Mess around in with minix for a bit. The Minix book (http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388) is wonderful. I only made it about half way through but it was one of the few "textbooks" I was able to actually sit and read. You may also want to drop back to Minix 2 as 3 is leaning more towards usability than education.

There is also linux .01 (try http://www.oldlinux.org/Linux.old/).

The main idea here is to stick to "early" code as it is clean, basic and without frills. Get the basics down then expand.

Its a little old but operating system design and implementation by Andrew Tanenbaum is a pretty good book and it includes a lot of the Minix source code in the book.

Hey, last year I followed a course in Operating Systems where we used MINIX as an example OS, which is one of the most understandable OS's out there, and great for learning.

This is a good (and quite pricey, unfortunately) book for MINIX and Operating Systems in general.

You could always buy the book...

https://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388

The best one for general OS design & implementation:

http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_1?s=books&ie=UTF8&qid=1411043393&sr=1-1&keywords=operating+system+design+and+implementation

Linux-specific:

http://www.amazon.com/Understanding-Linux-Kernel-Third-Edition/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1411043351&sr=8-1&keywords=understanding+the+linux+kernel

http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=pd_bxgy_b_text_z

Just read Tanenbaum's Operating System's Design and Implementation, and Lions' Commentary on Unix and you should be good to go.

A few books that helped me understand low level details of computers was

Assembly Language Step By Step: Programming With Linux

and

Operating Systems Designs and Implementation

I'd recommend Minix; in particular, version 2. Not only is the kernel quite small, there's also a book that walks you through its internal workings in detail, and a newsgroup to go to for help or questions.

Do you want to know which parts make an OS or how it's actually run in runtime. Former, is easy just install Arch, Gentoo or Linux From Scratch. Latter is a lot complicated nowadays but https://www.amazon.de/Operating-Systems-Implementation-Prentice-Software/dp/0131429388/ref=tmm_hrd_swatch_0?_encoding=UTF8&qid=&sr= is a great start or there's https://wiki.osdev.org/Tutorials if you want to go deep.

If you do both and combine the knowledge, your beard will grow 100x.

Source: I did but I am hairless 0*100 = 0 :/.

Operating System Design and Implementation, a classic (which...I hope is still relevant, but it's the first thing I thought of). Also good stuff in the recommenations.

Most operating systems are written in a combination of ASM (Assembly, which is machine code for x86/x86-64 processors), and C or C++.

If you're really serious about it, there is a book that walks through a basic operating system called MINIX (a minimal *nix OS). See: https://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/

Nowadays, modern operating systems are much more complex, though.

I found Operating Systems - Design and Implementation (3rd Edition) a surprisingly good read.

I would very much recommend http://www.amazon.com/Black-Video-Game-Console-Design/dp/0672328208 ; it goes really far in explaining everything from quantum level up to a working game console. And after that; http://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_1?s=books&ie=UTF8&qid=1405346881&sr=1-1&keywords=minix . Then you'll be set.

Edit; Although the Black art is about game consoles; if you work through it, you can build your own computer in the end, or, what I really like, you can pick up old machines (80s/begin 90s) from Ebay for < $5, open them up , understand them and change them. As they are not 'one chip' with some power supply stuff, but almost everything is held in separate ICs, so you can follow the PCB and see actually what it is doing and how. Great fun. And it scales, as I have no issue making digital things with FGPA's etc because I know it at this level.

I've tried doing something similar for x86 about a decade ago.

I've written this GUI a while back from scratch that could work from DOS (for things like loading images into memory). All those controls that you see in the picture worked well and how they should. I believe it only took like 3000-5000 lines of code to write it. How I started was, I already knew x86 assembly (not really needed for GUI part, unless you want to optimize) and C. I found some sort of Linux bootloader that had a GUI. I looked through its code and got a basic idea on how to write it. Its author used C++ (just for classes and inheritance), which is what I used. So for a GUI I recommend learning C and a bit of C++, then finding this bootloader (I don't remember the name) or some other relatively small project that has its own GUI and see how it's made.

For the OS part, I recommend a book called "Operating Systems Design and Implementation (3rd Edition)". You will need to know C and x86 assembly to understand it. It discusses how a particular OS named Minix was made. Linus Torvalds used the first edition of this book to write the first version of Linux.

You could google for something like "osdev", "osdev gui".

This book's a good start https://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/ref=sr_1_2?s=books&ie=UTF8&qid=1468514415&sr=1-2&keywords=Operating+Systems%3A+Design+and+Implementation

The Design of the Unix Operating System is a classic. It's from the 80's, but still plenty relevant. It's very well written, with plenty of diagrams to help you along.

It doesn't quite start from the very beginning. If you're looking for information on how to start with absolutely nothing (ie, write a bootloader, implement basic device drivers, etc), then you'll need to supplement with other sources. It does, however, do a really great job of explaining things like processes, threads, memory management, and other basic concepts. It doesn't give you source code (though it contains a bit of pseudocode), but it explains in succinct, legible prose, the data structures and algorithms that drive core functionality. Again, it's an old book - $6.00 plus shipping used. Can't really go wrong.

Operating Systems Design and Implementation covers basically the same ground. I prefer the former, as it treats you a little more like an adult and skips straight to explaining how concepts are implemented (and the cover art is just so undeniably classic).

> I want to learn how linux (and computers) work.

If you want to learn how Linux (and computers) work, take a course on operating system design and development. It's offered at any university that has a respectable computer science program, and you can probably find online courses that teach it for free. If you're more of a self-starter, grab a textbook and work your way through it. A book on the internal workings of Linux in particular might also be helpful, but IMO the development of the Linux kernel is too rapid for a book to provide a useful up-to-date reference.

If you want to learn Linux as a day-to-day user (which is what I suspect you're looking for), pick Ubuntu or one of its derivatives. They are easy to get up and running, while still allowing you to "spread your wings" when you're ready.

"The" book CS students read, and would be good for you, is:

http://www.amazon.com/Operating-Systems-Design-Implementation-Edition/dp/0131429388

It goes deep into OS design, but if you read it, then all the mysterious tips, explanations, and pointers you find online will make sense.