#121 in Computers & technology books
Reddit mentions of Modern Operating Systems (3rd Edition)
Sentiment score: 16
Reddit mentions: 29
We found 29 Reddit mentions of Modern Operating Systems (3rd Edition). Here are the top ones.
Buying options
View on Amazon.comor
- System: Intel Core i5-7400 3.0GHz | Intel B250 Express Chipset | 8GB DDR4 | 1TB HDD | Genuine Windows 10 Home 64-bit
- Graphics: AMD Radeon RX 580 4GB Video Card | 1 x HDMI | 1 x DisplayPort
- Connectivity: 5 x USB 3.1 | 2 x USB 2.0 | 1 x RJ-45 Network Ethernet 10/100/1000 | 802.11AC Wi-Fi | Audio: 7.1 Channel | Keyboard and Mouse
- Special Feature: 802.11 AC Wi-Fi
- Warranty: 1 Year Parts & Labor Warranty | Free Lifetime Tech Support
- NOTE: Refer the Instructional Video from image section before use which is highly essential.
Features:
Specs:
Height | 9.4 Inches |
Length | 7.4 Inches |
Number of items | 1 |
Weight | 3.87131732072 Pounds |
Width | 1.6 Inches |
First of all you don't need to write a billion lines of code to create an OS. The first version of Minix was 6000 lines long. The creator of Minix, Andrew Tanenbaum, has a great book called Modern Operating Systems, in which he explains the inner workings of several famous operating systems.
Considering the emphasis on "from scratch", you should also have a very good understanding of the underlying hardware. A pretty good starter book for that is Computer Organization and Design by David A. Patterson and John L. Hennessy. I suggest reading this one first.
​
I hope this can get you started.
Yup, check this out:
[India: 360 Rupees (about 6.59$)](
http://www.flipkart.com/modern-operating-systems-8120339045/p/itmdytdczrzjrwgq?pid=9788120339040&ref=93cc510a-81d9-41c2-a5b9-f4a0a0760070)
US: 126.73$
Quality of paper is not the same though. And no colour diagrams, its all black and white in India. And paperback instead of Hardcover.
This might be a good step by step way of doing it:
Depending on skill and knowledge level you might want to skip the first two or one of them at least.
You might have some better luck if you go top down. Start out with an abstracted view of reality as provided by the computer, and then peel off the layers of complexity like an onion.
I would recommend a "bare metal" approach to programming to start, so C is a logical choice. I would recommend Zed Shaw's intro to C: http://c.learncodethehardway.org/book/
I would proceed to learning about programming languages, to see how a compiler transforms code to machine instructions. For that, the classical text is the dragon book: http://www.amazon.com/Compilers-Principles-Techniques-Tools-Edition/dp/0321486811
After that, you can proceed to operating systems, to see how many programs and pieces of hardware are managed on a single computer. For that, the classical text is the dinosaur book: http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/1118063333 Alternatively, Tannenbaum has a good one as well, which uses its own operating system (Minix) as a learning tool: http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639/ref=sr_1_1?s=books&ie=UTF8&qid=1377402221&sr=1-1
Beyond this, you get to go straight to the implementation details of architecture. Hennessy has one of the best books in this area: http://www.amazon.com/Computer-Architecture-Fifth-Quantitative-Approach/dp/012383872X/ref=sr_1_1?s=books&ie=UTF8&qid=1377402371&sr=1-1
Edit: Got the wrong Hennessy/Patterson book...
http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X
or the previous edition
http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639
Both have a Linux case study after going through the details of what makes an OS.
Your not going to have a RHEL specific book of this nature because a distro like RHEL is a mash of so many different and huge projects that are under constant development. If you want to know the ins and outs of GNOME for instance, you're going to have to delve into the GNOME developer documentation, same with things like Systemd and GLIBC
This and this by Tanenbaum are the best books on the topic i have read until now.
As you can imagine, the kernel is a gigantic project, so it's hard to jump in and understand how things are working. If this is your first exposure to any operating system stuff, I would suggest backing up and learning a bit more of the basics. You'll find information like that under the terms "computer architecture" and "computer organization". Modern Operating Systems by Tanenbaum is a classic read to get started.
If you really want to dig at the kernel code, I'd recommend Robert Love's Linux Kernel Development. It gets into the details of process scheduling, interrupts, memory management, file systems, etc. and looks at the code. But I'd warn you that it's pretty complex and can be quite slow to learn.
There are a few free linux kernel books online such as Advanced Linux Programming and Linux Device Drivers. Even if some of the information is outdated, you'll get a lot of information about how the kernel works in general from these resources.
Hope that helps, and enjoy.
No, and I'll tell you why. Arch isn't a horrid distro, I just don't like the Arch philosophy or mentality that a lot of the newbies have. People use Arch for the wrong reasons, mainly "to learn Linux", which kinds grinds my gears. Hell, I just had this talk with someone today so it's kinda fresh in my mind.
Also, if you want to learn OS concepts, read Operating Systems Concept by Silberschatz or Modern Operating Systems by Tanenbaum, both better sources of learning what an OS does than Arch.
My final word before I get downvoted to oblivion, just because something is harder than it should be doesn't mean it's a good educational tool. If that were true, you'd be using a BSD derivative over Arch Linux.
Andrew Tanenbaum's book is often used in college courses. It describes what services an operating system has to provide, different options in terms of overall structure, etc. It doesn't necessarily tell you the practical side of writing one (as far as I remember). Anyhow, the book would probably be a good place to start.
Modern Operating Systems by Andrew Tanenbaum is a good book, we used it as the textbook for my OS course in university.
Most advanced processors have a memory management unit (an MMU). It's a hardware mechanism for limiting the access a program has to memory (be it RAM, or memory-mapped hardware like graphics cards)
It has at least two modes: a "kernel mode" accessed only by the OS, in which the entirety of memory is available; and a "user mode", accessed by regular programs, in which only data that belongs to this program is accessible. While running in user mode, the program won't be able to read data of another program, or anything like that. This is called virtual memory and is essential for providing security (otherwise, programs might be able to read data from other programs).
Periodically, the processor will interrupt the program that is running and pass the control back to the operating system. This is called [preemptive multitasking](http://en.wikipedia.org/wiki/Preemption_(computing). The OS can then pass control to some other program. The goal here is to give each program a fair share of processor time. This is accomplished by the process scheduler.
[ Scheduling was a somewhat heated area on Linux some years ago, where Con Kolivas, an amateur kernel hacker, proposed schedulers (the rotating staircase deadline scheduler and later the brain fuck scheduler) that would improve interactivity, but his code was rejected and he left (but eventually a code with similar goals was incorporated in Linux) ]
External events, like pressing the keyboard, moving the mouse, or receiving data from internet will interrupt the running program too, and pass control to the OS. Ever wondered why you can do ctrl+alt+del (or something like Alt+SysRQ+B in Linux) even if the computer seems to have hanged? While the graphical interface might be frozen, keyboard input is delivered by interrupts, and so if the processor is running it's always delivered. (sometimes the kernel is running out of memory or is having some other problem and has a hard time fulfilling user input - but it always gets delivered)
Also, the OS shouldn't be doing a lot of work inside the interrupt. What if another interrupt fires while he is at it? To prevent that, it disables interrupts. Non-urgent bookkeeping code competes for processor time just like regular programs, and have to go through the scheduler.
Anyway, what if a program wants to read a file, or send data to Internet? It must call a system call. It passes control to the operating system, which can do a lot of things. Sometimes, the program asked something that will take a while - for example, asked to read a file, which can take some milliseconds on a hard disk - and the kernel puts it to sleep. In the mean time it can then schedule other programs, and will wake the program when its data arrives.
The other major thing that is missing are drivers. Processors can communicate with the external world by means of pins that carry electrical signals. Those pins are typically connected to a bus like PCI express, which in turn ultimately connects everything to the processor - keyboard, mouse, graphics card, sound card, etc. While the processor handles the low-level aspects of the bus (and the BIOS does some device initialization), it's the kernel that is in charge of actually receiving and sending data to each of those devices. It's sometimes done by using memory-mapping (so the kernel writes and reads from some pre-determined part of memory to communicate to a device), but there are other methods. Each device has its own way to talk with the processor, and the kernel has to learn it all. Because, what use would have a kernel if you couldn't display anything on a monitor and couldn't type with a keyboard?
I didn't touch everything about operating systems, but anyway, interrupts and syscalls bring operating systems to live, drivers makes operating systems useful, and MMUs makes it much easier to write secure operating systems. While you can run Linux without a MMU, for such processors it's more common to write your code without an operating system (those processors are typically called microcontrollers and are used in embedded environments, like a children's toy or controlling an industrial plant - often you don't need a full blown operating system!)
Anyway, notice that I used "operating system" and "kernel" interchangeable here. That's because in computer science terms, they are the same (and when you study operating systems at university, you normally are studying kernels. For example Modern Operating Systems, a classic book on the field, is about kernels). Also, where I said "processor" you could say "CPU".
Another thing: there is also the idea that current kernels are too bloated, and we should move code from the kernel to user programs (what's left is a minimal kernel called microkernel). For example, you could write device drivers and filesystems as regular programs, instead of having them in the kernel. That way, if they crash, they won't bring the whole system down (the blue screen of death of Windows fame happened mostly due to crappy device drivers). The opposite of microkernel is monolithic kernel. The trouble with microkernels is that they are slower, sometimes considerably so.
Hi,
To design and program a (very) tiny operating system, I would recommand you to learn C in an Unix environnement. C has absolutly no automated memory management and is a pre-requisite to OS programming and in particular in kernel programming. User level could be developped in any almost any language but that's another discussion.
But above all, you need to understand what is an operating system and how it is architectured in its common forms. There are several basic architectures you must know and undestand deeply. But if you cannot say the difference between a kernel and an operating system, you should first give a read to this book. Unlike many other famous computer science books, this one is an absolute must read (haters gonna hate).
If you're already familiar with basics, a good first step might be to write a dummy kernel module for your favorite Unix. You will discover a less known part of your OS api and with the help of man pages, you will be eventually able to write a "cat" or "echo" driver. From here, well, the limit is your imagination. After that (at least a year from today ;) ), you could start to design and implement the first lines of an "OrlandoFuriosoOS", but it's a long and bitchy road :D.
The famous Tanenbaum circus, for those who haven't seen it:
http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639
Nah, http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639.
Modern Operating Systems (3rd Edition)
Excellent book!
You can't forget Tanenbaum: http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639/ref=sr_1_1?s=books&ie=UTF8&qid=1302667905&sr=1-1
Or the design of the BSD operating system: http://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0201702452/ref=sr_1_2?s=books&ie=UTF8&qid=1302667950&sr=1-2
Two Must-haves for any *nix // C guys out there!
I always buy my textbooks in India (get someone to ship it). I have spent a total of $60 in the last 2 years on text books. Yes, some textbooks that are ~$150here are the equivalent of ~$8 there.
Here: http://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639 - $156
India: http://www.sapnaonline.com/index.php?option=com_books&view=product&productID=EBK0006776&product=MODERN-OPERATING-SYSTEMS - 360Rs = $8
First, you need to learn C and be very comfortable with it -- this happens when you work on a large project with multiple source files, especially when you start one from scratch yourself.
Second, you need to learn about operating system/kernel fundamentals -- C is just a tool/language. You need to know a lot about what you're developing! So get a book on OS -- http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639 or http://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720 , or reading lecture notes from your school (preferrably from a very good Computer Science school). Here's one: http://www.student.cs.uwaterloo.ca/~cs350/W11/reading.html
Third, start exploring the kernel source code and try and figure what things are and how things work. Subscribe to linux mailing lists, read more articles on how Linux internals work, etc.
The most important step here is step number 2! It will require the most work and the most effort.
It'll be challenging and fun, and will take quite a lot of time :) Be persistant and good luck!
Not sure if it's for Linux or OS in general. The other links here are a nice look at Linux in general. These are the two textbooks used in most modern OS classes:
Honestly, I find the first much easier to read. The second discusses things at a verbose and somewhat rambling fashion. They're both good for learning the real ideas behind modern operating systems, though.
Senior Level Software Engineer Reading List
Read This First
Fundamentals
Development Theory
Philosophy of Programming
Mentality
Software Engineering Skill Sets
Design
History
Specialist Skills
DevOps Reading List
Andrew Tanenbaum (guy who made MINIX) has a pretty decent book on Operating Systems. It has had a number of iterations, here is one.
http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/0136006639?tag=r601000010-20
I don't personally own it, but my friend who built an OS in his free time gives it his highest recommendation.
The two Andrew Tanenbaum books are usually a really good place to start.
Operating Systems: Design and Implementation
Modern Operating Systems
They are admittedly x86 based books, but they'll introduce you to actual OS design concepts, and then it's a "simple" matter of actually digging in to the documentation for the hardware you're writing it for and then start building.
They're not really covered as a distinct topic - you'll tend to see them wrapped up in other books from what I've seen. Sorry this is not going to be as simple of an answer as you're hoping for, but I'm trying to give you a clear picture. I don't know of one good book - maybe, hopefully someone else does.
There's the theoretical side, covering parallel execution models. Look for senior undergrad or graduate level parallel algorithms courses. There should be lots of material online. Some good discussion here: https://developer.nvidia.com/content/what-are-your-favorite-parallel-programming-references
On the practical side, pthreads is probably the most commonly used threading library in the non-Windows world and is not that hard to learn from example. None of the individual concepts are that hard, it just introduces great potential for complexity and tough debugging when you have a bunch of locks scattered throughout your program and you're trying to make sure you're always acquiring and releasing them in the same order, as one example problem.
If you learn all that and then add in some atomic operations and non-blocking algorithms, and maybe message passing, all of which are fairly tractable to learn by searching for examples, you should be in pretty good shape.
I also like the OS perspective on this stuff. Tanenbaum covers this well if I remember right.
OSDever
Solaris: Internals was also really good, combined with Tannenbaum's book (not the Minix book, the good one)
I'd recommend Tanenbaum's Modern Operating Systems, that should get you started on beginning to understand what goes on inside your computer. If you'd like further reading and you want a mental beat-down, you can't go wrong with Knuth's The Art of Computer Programming. Want to start with programming? One of my favorites is The C Programming Language by K&R. Those three recommendations, while they add up to a single semester's tuition, are worth way more than that. Good luck!
Try having a look at this book http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639. I've only got past the first chapter or so but it may answer some of your questions.
No, but looking into it I wish we had.
We used Modern Operating Systems 3rd Edition also by Tanenbaum.
I think what we can conclude from this is that the man really knows his shit, both about teaching and about operating systems.
In my experience, books work great for non-fiction too. I read Modern Operating Systems by Andrew Tanenbaum and learned more about operating systems faster than I could online. Yes, all of the information is online and easily accessible, but by putting all of that information into a single 1000 page book, the author can more easily control how you learn the information. Instead of reading scattered fragmentary articles on individual parts of an operating system, many of which assume you know about more advanced topics, you can read a book and the author will start you off with simple groundwork, then more to more advanced stuff while making sure that you know everything leading up to that point. Even though the book was several years outdated when I read it, the knowledge that I gained from it let me learn about more recent topics easier.
A book, by virtue of its very long format, can more easily present information in a structured and progressive manner that ensures that the reader truly learns the information presented. Of course, everyone learns differently, but I personally like how a book guides me through the topic.
Yeah, programs doesn't need to know what the speed of your processor is...
Don't you think that microsoft has considered this? If you think my argument is purely semantics i have some good books on the matter that i can refer to
http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639
This one is particularly good