#121 in Computers & technology books
Use arrows to jump to the previous/next product

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.

Modern Operating Systems (3rd Edition)
Buying options
View on Amazon.com
or
    Features:
  • 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.
Specs:
Height9.4 Inches
Length7.4 Inches
Number of items1
Weight3.87131732072 Pounds
Width1.6 Inches

idea-bulb Interested in what Redditors like? Check out our Shuffle feature

Shuffle: random products popular on Reddit

Found 29 comments on Modern Operating Systems (3rd Edition):

u/raz_c · 30 pointsr/programming

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.

u/ashimjyoti · 16 pointsr/LifeProTips

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.

u/[deleted] · 14 pointsr/programming

This might be a good step by step way of doing it:

u/mcur · 14 pointsr/linux

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...

u/mhurron · 10 pointsr/linuxadmin

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

u/aiCikey · 7 pointsr/learnprogramming

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

u/zyrkan · 7 pointsr/linux

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.

u/enroxorz · 6 pointsr/linux

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.

  • Some people think you get a "performance" gain from switching. The only distro I know that you can get that claim is Gentoo, and it's minimal compared to the hassles inherited in getting the system up and running (last time I touched Gentoo was 2005).

  • Rolling Release sounds nice until a tool that you have been using for ages goes away (ifconfig, route). I want stability and the choice to not upgrade to the latest and greatest, especially on teh server side (sarge has been keeping one of my sites up and running for ages and never had an issue)

  • "Learning Linux" is misleading. I hear this a lot, and it's malarkey. Any distro can "teach you linux". Just because your installation is a hassle doesn't mean you are a good teacher. If you want to learn how a distro works, Linux From Scratch is a way better project. Other than that Learning Linux, for the average user, should be centralized to knowing your system in a high level AND understanding your CLI and Shell

    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.
u/khedoros · 4 pointsr/learnprogramming

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.

u/TehLittleOne · 3 pointsr/learnprogramming

Modern Operating Systems by Andrew Tanenbaum is a good book, we used it as the textbook for my OS course in university.

u/protestor · 2 pointsr/explainlikeimfive

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.

u/thornska · 2 pointsr/IWantToLearn

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.

u/imforit · 2 pointsr/ProgrammerHumor

The famous Tanenbaum circus, for those who haven't seen it:

http://www.amazon.com/Modern-Operating-Systems-3rd-Edition/dp/0136006639

u/vin200 · 2 pointsr/EngineeringStudents

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

u/exacube · 2 pointsr/linux

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!

u/kaosjester · 2 pointsr/linux4noobs

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:

  • The Circus Book - Modern Operating Systems
  • The Dinosaur Book - Operating System Concepts

    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.
u/CSMastermind · 2 pointsr/AskComputerScience

Senior Level Software Engineer Reading List


Read This First


  1. Mastery: The Keys to Success and Long-Term Fulfillment

    Fundamentals


  2. Patterns of Enterprise Application Architecture
  3. Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  4. Enterprise Patterns and MDA: Building Better Software with Archetype Patterns and UML
  5. Systemantics: How Systems Work and Especially How They Fail
  6. Rework
  7. Writing Secure Code
  8. Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries

    Development Theory


  9. Growing Object-Oriented Software, Guided by Tests
  10. Object-Oriented Analysis and Design with Applications
  11. Introduction to Functional Programming
  12. Design Concepts in Programming Languages
  13. Code Reading: The Open Source Perspective
  14. Modern Operating Systems
  15. Extreme Programming Explained: Embrace Change
  16. The Elements of Computing Systems: Building a Modern Computer from First Principles
  17. Code: The Hidden Language of Computer Hardware and Software

    Philosophy of Programming


  18. Making Software: What Really Works, and Why We Believe It
  19. Beautiful Code: Leading Programmers Explain How They Think
  20. The Elements of Programming Style
  21. A Discipline of Programming
  22. The Practice of Programming
  23. Computer Systems: A Programmer's Perspective
  24. Object Thinking
  25. How to Solve It by Computer
  26. 97 Things Every Programmer Should Know: Collective Wisdom from the Experts

    Mentality


  27. Hackers and Painters: Big Ideas from the Computer Age
  28. The Intentional Stance
  29. Things That Make Us Smart: Defending Human Attributes In The Age Of The Machine
  30. The Back of the Napkin: Solving Problems and Selling Ideas with Pictures
  31. The Timeless Way of Building
  32. The Soul Of A New Machine
  33. WIZARDRY COMPILED
  34. YOUTH
  35. Understanding Comics: The Invisible Art

    Software Engineering Skill Sets


  36. Software Tools
  37. UML Distilled: A Brief Guide to the Standard Object Modeling Language
  38. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development
  39. Practical Parallel Programming
  40. Past, Present, Parallel: A Survey of Available Parallel Computer Systems
  41. Mastering Regular Expressions
  42. Compilers: Principles, Techniques, and Tools
  43. Computer Graphics: Principles and Practice in C
  44. Michael Abrash's Graphics Programming Black Book
  45. The Art of Deception: Controlling the Human Element of Security
  46. SOA in Practice: The Art of Distributed System Design
  47. Data Mining: Practical Machine Learning Tools and Techniques
  48. Data Crunching: Solve Everyday Problems Using Java, Python, and more.

    Design


  49. The Psychology Of Everyday Things
  50. About Face 3: The Essentials of Interaction Design
  51. Design for Hackers: Reverse Engineering Beauty
  52. The Non-Designer's Design Book

    History


  53. Micro-ISV: From Vision to Reality
  54. Death March
  55. Showstopper! the Breakneck Race to Create Windows NT and the Next Generation at Microsoft
  56. The PayPal Wars: Battles with eBay, the Media, the Mafia, and the Rest of Planet Earth
  57. The Business of Software: What Every Manager, Programmer, and Entrepreneur Must Know to Thrive and Survive in Good Times and Bad
  58. In the Beginning...was the Command Line

    Specialist Skills


  59. The Art of UNIX Programming
  60. Advanced Programming in the UNIX Environment
  61. Programming Windows
  62. Cocoa Programming for Mac OS X
  63. Starting Forth: An Introduction to the Forth Language and Operating System for Beginners and Professionals
  64. lex & yacc
  65. The TCP/IP Guide: A Comprehensive, Illustrated Internet Protocols Reference
  66. C Programming Language
  67. No Bugs!: Delivering Error Free Code in C and C++
  68. Modern C++ Design: Generic Programming and Design Patterns Applied
  69. Agile Principles, Patterns, and Practices in C#
  70. Pragmatic Unit Testing in C# with NUnit

    DevOps Reading List


  71. Time Management for System Administrators: Stop Working Late and Start Working Smart
  72. The Practice of Cloud System Administration: DevOps and SRE Practices for Web Services
  73. The Practice of System and Network Administration: DevOps and other Best Practices for Enterprise IT
  74. Effective DevOps: Building a Culture of Collaboration, Affinity, and Tooling at Scale
  75. DevOps: A Software Architect's Perspective
  76. The DevOps Handbook: How to Create World-Class Agility, Reliability, and Security in Technology Organizations
  77. Site Reliability Engineering: How Google Runs Production Systems
  78. Cloud Native Java: Designing Resilient Systems with Spring Boot, Spring Cloud, and Cloud Foundry
  79. Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
  80. Migrating Large-Scale Services to the Cloud
u/lxplot · 1 pointr/learnprogramming

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.

u/MorphiusFaydal · 1 pointr/learnprogramming

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.

u/incredulitor · 1 pointr/compsci

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.

u/BrainInAJar · 1 pointr/compsci

OSDever

Solaris: Internals was also really good, combined with Tannenbaum's book (not the Minix book, the good one)

u/Freak-Power · 1 pointr/geek

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!

u/regimental · 1 pointr/learnprogramming

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.

u/Triddy · 1 pointr/programming

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.

u/Ranger207 · 1 pointr/todayilearned

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.

u/Trainbow · 0 pointsr/technology

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