Reddit reviews Modern Operating Systems (4th Edition)
We found 39 Reddit comments about Modern Operating Systems (4th Edition). Here are the top ones, ranked by their Reddit score.
Reddit reviews Modern Operating Systems (4th Edition)We found 39 Reddit comments about Modern Operating Systems (4th Edition). Here are the top ones, ranked by their Reddit score.
Going through the Stanford List, here are the books listed there that I have also used and thought positively of:
Of the list, the only one I have read and didn't like was Operating System
Concepts. It's not that it was terrible, per se, I just liked Modern Operating Systems a lot more. I used the third edition, but I can't imagine the 4th is any worse.
"Introduction to Algorithms"by Cormen et.al. Is for me the most important one.
The "Dragon" book is maybe antoher one I would recommend, although it is a little bit more practical (it's about language and compiler design basically). It will also force you to do some coding, which is good.
Concrete Mathematics by Knuth and Graham (you should know these names) is good for mathematical basics.
Modern Operating Systems by Tennenbaum is a little dated, but I guess anyone should still read it.
SICP(although married to a language) teaches very very good fundamentals.
Be aware that the stuff in the books above is independent of the language you choose (or the book chooses) to outline the material.
I really enjoyed this text in my operating systems course. https://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X
I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.
Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.
Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
>I do have a textbook called "C: A modern approach" by King, but like I said before, I think it focuses more on the coding aspect.
Most books that focus on C are going to be about learning the language. If you want to learn low level stuff, you need to find books that focus on them (and they'll usually incidentally use C). The language itself is quite small and minimalistic in what it can do. Most heavy handed things like networking and GUIs require interaction with the OS.
Eg, if you wanted to do networking, you could use the Windows API or the POSIX socket API (POSIX being the standards that *nix systems follow -- and certain versions of Windows). Or you could use a higher level library like curl for cross platform support (and a wealth of nicer features).
>Can somebody please guide me on where to start?
Firstly, as much of a linux fanboy I am, I do want to make sure you know that you don't need to use Linux for any of the other things you wanted to learn (low-level programming, command lines, networking, etc). In fact, my OS class mostly used Linux, but we started out with a project using Windows threads (I guess the prof wanted us to see the difference from POSIX threading).
All that said, I do think Linux is something you'd want to learn and that a lot of low level things just seem more natural in Linux. But I'm biased. Linux fanboy, remember?
I'd start with downloading a Linux OS. Doesn't really matter which. I'd recommend going with Ubuntu. It's the most popular, easiest to find help with, and seems to be what most web servers are running, to boot. You can play around with the GUI for a bit if you want. It won't feel that different. Modern OSes sort of converged into the same high level ideas.
My favourite book for getting into the command line ever so slightly touching the low level aspects of OSes is Mark Sobel's A Practical Guide to Linux Commands, Editors, and Shell Programming. It will include some basic knowledge of Linux, but mostly focuses on the command line. But this is very useful because not only is the command line very practical to learn, but you'll end up learning a lot about Linux in the process (eg, by learning how everything is a file, how pipes work, etc). And arguably the command line a super big part of Linux, anyway. It makes sense as the first step.
Now, for the next step, you need to know C very well. So finish with your class, first. Read ahead if you have to. Yes, you already know if statements and functions and all, but do you understand pointers well? How about function pointers and void pointers? Do you understand how C's arrays work and the usage of pointer arithmetic? How about how arguments are passed to functions and when you'd want to pass a pointer to a function instead? As a rough skill testing question, you should implement a linked list for arbitrary data types with functions such as prepending, appending, concatenating lists, searching, removing, and iterating through the list. Make sure that your list can be allocated and freed correctly (no memory leaks).
Anyway, the next step is to learn OSes. Now, I said OSes and not Linux, because the Linux OS is a bit constrained if you want to learn low level programming (which would include a knowledge of what OSes in general do, and alternatives to OSes like Linux). But never fear, pretty much any OS book will heavily use Linux as an example of how things work and consequently explain a great deal of Linux internals. I can't recommend a class because mine was a regular university class, but Tanenbaum's Modern Operating Systems is a good book on the subject.
In particular, you can expect an OS class to not merely be focused on building an OS yourself (my class worked on aspects of OS101 to implement portions of our own OS), but also on utilizing low level aspects of existing OSes. Eg, as mentioned, my class involved working with Linux threading, as well as processes. We later implemented the syscalls for
fork,join, etc ourselves, which was a fascinating exercise. Nothing gets you to understand how Linux creates processes like doing it yourself.Do note, however, that I had taken a class on computer architecture (I found Computer Organization and Design a good book there, although note that I never did any of the excerises in the book, which seem to be heavily criticized in the reviews). It certainly helps in understand OSes. It's basically as low as you can go with programming (and a bit lower, entering the domain of computer engineering). I cannot say for sure if it's absolutely necessary. I would recommend it first, but it's probably skippable if you're not interested (personally, I found it phenomenally interesting).
For learning networking, Beej's book is well written. You don't need to know OSes before this or anything.
Thanks ;). Not so skilled on that and my advice might be misleading; though I got a background in cs:This would be my suggestion for someone beginning.
You can also search for those books pdf by using google hacks eg
filetype:pdf "title of the book here"orintitle:index.of "title of the book here"I think it's time for you to read a text book about virtual memory and page tables. There's a lot going on under the hood.
The short answer is, every process lives in its own virtual space, which appears to the process to be the whole of system memory. For that process, the only things that exist are its own memory and the kernel parts which are mapped into it. The only way a process can see other process memory is via the kernel.
The longer answer is that the way the kernel achieves is this is through a couple of bits of hardware in particular the MMU (memory management unit) which includes the TLB (translation lookaside buffer). The TLB is a kind of cache that handles fast lookups from virtual addresses (that a process sees), to physical addresses (that the kernel sees and manages). A TLB lookup will fail if a process tries to access a virtual address that is not mapped into it. In this case, the kernel (or on x86, the MMU on behalf of the kernel) will consult a bunch of tables ("page tables") to find the mapping and load it. If the kernel can't find the memory, then your process is trying to access memory that was never allocated to it, and you get a segfault (the memory segment couldn't be found).
There's a lot to it, and a single reddit comment isn't the place to get into all the details. I'd take a look at Modern Operating Systems or any other decent text book for a full explanation.
Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.
Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
Modern Operating Systems:
http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X/ref=sr_1_1/183-0673173-4956401
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
It’s gonna be hard to give you much without picking a specific OS—details can vary widely even within a single OS family line—but an OS book is probably a good place to start. Tanenbaum’s book is the go-to.
Alternatively, there are books on specific techniques like garbage collection, or books more generally on programming for UNIX/POSIX/Linux or Windows (via Win16/32/64 API, not the six-mile-high shitheap piled atop), which would tell you some about how memory management works in down at least to whatever abstract hardware interface the kernel uses.
Every sysadmin must read a https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X . This book teaches what operating system is, how it works and why specific decisions were made when people designed parts of it. Some programming knowledge required to get more from this book, but it's mandatory in the IT field now anyway. Reading this book really extended my troubleshooting capabilities as I got a clearer picture of how things work in my head.
https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X
I've posted this before but I'll repost it here:
Now in terms of the question that you ask in the title - this is what I recommend:
Job Interview Prep
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
Specialist Skills
In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
Master this and you'll become a ninja :
Well in that case, if you haven't already make sure to look into Computer Architecture, Assembly Language (I don't recommend actual assembly try something like MIPS), and Digital Logic. Those all really helped me when I was learning OS's and stuff past trivial C programs. Keep in mind that they rarely DIRECTLY helped me, moreso they helped me to understand some of the more advanced topics that build on the lower levels of the system. They should help you to understand more of control flow down to the instruction level and help you to understand why some solutions are implemented through hardware and some through software.
With all that said, my recommendation is really cliche. But if you want to learn advanced operating system concepts then I recommend: Modern Operating System Concepts.
That is a newer edition but you'd be fine going with a cheaper used edition that's older. If it's not sold out this link on thriftbooks is a good place to look. Second Edition
A good starting point for studying OS is Tanenbaum's Modern Operating Systems, but of course there are other, more detailed resources.
Read Clean Code and build a non trivial project using the principles from that book. You'll learn a lot.
Maybe read an Operating Systems book, pick a subsystem you find interesting and try to understand how Linux implements it.
Learn about git and source control.
Contribute to open source projects you find interesting.
Try setting up a server and configuring it to do cool stuff.
Basically, identify something that you don't know much about and dive deeper, or just write lots and lots of code.
Modern operating systems by Andrew Tanenbaum
I think that system programmers should know how OSs work. Concepts like virtual memory, the call stack and paging may be the answer to your question about when to consider something to be big
Tanenbaum's bible will most likely be the course literature for your upcoming operating system class at university. It's a bit pricy, but I'm sure your local library or pirate bay has a copy. Doesn't hurt to dig into it early.
That said, modern computers can be a bit overwhelming. Banging directly on hardware was commonplace for any program back in the C64/Amiga days. If you have any interest in retro computers, these are very well documented by now.
Edit: I guess I was actually thinking of this book
It's worth it to try every approach and make you own decision.
Don't forget to read something like Modern Operating Systems (4th Edition) https://www.amazon.com/dp/013359162X/ref=cm_sw_r_cp_apa_i_HTBVDbGBKG5Q0b to better understand how it actually works.
More like CS University curriculum. Such as https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/
Modern Operating Systems. the 4th edition was release in March 2014.
http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X
Two commonly recommended books on this topic are The Dinosaur Book and Modern Operating Systems. For something a little more concise (and free) you could try Operating Systems: Three Easy Pieces.
For an actual course, you could try Computer System Engineering from MIT Open Courseware.
If you look for literature: Andrew Tanenbaum has written some books, especially Modern Operating Systems (http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X, but please don't buy it on Amazon, go to your local dealer or library). Tanenbaum's books and operating system Minix were also inspiration and help for Linus Torvalds when starting Linux.
To get back to technology :P
I personally didn't find assembler actually interesting because it's too low-level (you have to do too much work to achieve anything), so I didn't actually learn it (although I am able to roughly understand some disassembled code). My feeling regarding the bashing of C is that many people are afraid of it – because it is too complicated, or too dangerous, or they don't understand pointers or whatever, so they talk negatively about it. C is anything but archaic, it is essential to modern computing. The same with C++: Many people hate it (although many of them don't even know it) because they don't understand its concept: That you may do anything, but that you are responsible for it. The language gives you an amount of power not provided by languages like Python, Java or C#. They reverse this fact and say things like "duh, memory leaks" or "duh, segmentation fault" – just because they were bad programmers at the time they tried C++ and didn't manage to accomplish anything but segmentation faults. C++ is in fact the most complex language currently available, I can't think of another language requiring such a high skill level for safely writing production apps.
What I know, I learned from a book. Unfortunately, the book was purchased before Amazon, Kindle, etc. so I only have it in physical form far away from where I find myself physically right now so I can't remember the name. This one is probably very good (maybe even a newer edition of the same).
>> You are confusing sections with segments
> and you're behaving the way C++ usually behave
I am not a C++ anything. I have 25 years of experience with C and 20 years of experience with operating system design and development. The odds are better than even that both the computer you used to post this abusive rant and the computers which reddit use to store and serve it run code that I have written.
(Yes, I've been writing C++ on and off for almost as long as I've been writing C, but I vastly prefer the latter.)
> code section or code segment or text section or test segment are same in this context
Absolutely not. Segments are a feature of some computer architectures, most prominently the Intel 8086 and 80386 (but not their 64-bit descendants), used to organize and access code and data in memory. Sections are a feature of most executable file formats (such as ELF and COFF) used on modern non-embedded platforms. The OS and / or the run-time linker read code and data from sections in the executable file and store them somewhere in memory.
> simple googling gives you the result: https://stackoverflow.com/questions/2589949/string-literals-where-do-they-go
Stack Overflow is not a reliable source of correct* information (see for instance this article or this one about how SO's karma system encourages a race to the bottom). I would suggest reading Tanenbaum or McKusick et al. instead.
This specific answer is correct only in the sense that the literals are included in the same file as the code. Setting aside embedded platforms and their idiosyncrasies, they are stored in different sections of the file and loaded into different memory locations at run-time.
> Where do they go? the same segment where the .text section of the object file gets dumped, which has Read and Exec permissions, but not Write
Your information is 20 to 30 years out of date. No modern OS uses segments the way Intel envisioned when they designed the 8086 or the 80386. The former needed segments to escape pointer size limitations when the address bus outgrew the registers, and the latter retained them for backward compatibility and added memory protection features on a per-segment basis. However, modern OSes for the 80386 and its descendants implement memory protection at the page table level rather than at the segment level and use segment registers purely as conveniences for array operations, which is why they were left out when the 80386 architecture was expanded to 64 bits.
> But go ahead c++ pleb continue **** your *** like your kind always does.
I understand that it can be hard to admit that you are wrong, but that's not a reason to resort to that kind of language.
My professor recommended the book "Modern Operating Systems" for one of our classes. It's certainly not for everyone, the class was split about 50/50 on whether they absolutely hated it or loved it. There are copies to be found online if you're interested in checking out the writing-style, but I seriously recommend buying it if you do enjoy it as it is clearly a product of passion.
It's been an absolutely fantastic resource to me and although, as the name implies, it mostly focuses on operating systems, they manage to strike a seemingly perfect balance between explaining concepts of operating systems while still giving a thorough review of what role the actual hardware plays in the mix and how that works as well.
> For those who prefer video lectures, Skiena generously provides his online. We also really like Tim Roughgarden’s course, available from Stanford’s MOOC platform Lagunita, or on Coursera. Whether you prefer Skiena’s or Roughgarden’s lecture style will be a matter of personal preference.
>
> For practice, our preferred approach is for students to solve problems on Leetcode. These tend to be interesting problems with decent accompanying solutions and discussions. They also help you test progress against questions that are commonly used in technical interviews at the more competitive software companies. We suggest solving around 100 random leetcode problems as part of your studies.
>
> Finally, we strongly recommend How to Solve It as an excellent and unique guide to general problem solving; it’s as applicable to computer science as it is to mathematics.
>
>
>
> [The Algorithm Design Manual](https://teachyourselfcs.com//skiena.jpg) [How to Solve It](https://teachyourselfcs.com//polya.jpg)> I have only one method that I recommend extensively—it’s called think before you write.
>
> — Richard Hamming
>
>
>
> ### Mathematics for Computer Science
>
> In some ways, computer science is an overgrown branch of applied mathematics. While many software engineers try—and to varying degrees succeed—at ignoring this, we encourage you to embrace it with direct study. Doing so successfully will give you an enormous competitive advantage over those who don’t.
>
> The most relevant area of math for CS is broadly called “discrete mathematics”, where “discrete” is the opposite of “continuous” and is loosely a collection of interesting applied math topics outside of calculus. Given the vague definition, it’s not meaningful to try to cover the entire breadth of “discrete mathematics”. A more realistic goal is to build a working understanding of logic, combinatorics and probability, set theory, graph theory, and a little of the number theory informing cryptography. Linear algebra is an additional worthwhile area of study, given its importance in computer graphics and machine learning.
>
> Our suggested starting point for discrete mathematics is the set of lecture notes by László Lovász. Professor Lovász did a good job of making the content approachable and intuitive, so this serves as a better starting point than more formal texts.
>
> For a more advanced treatment, we suggest Mathematics for Computer Science, the book-length lecture notes for the MIT course of the same name. That course’s video lectures are also freely available, and are our recommended video lectures for discrete math.
>
> For linear algebra, we suggest starting with the Essence of linear algebra video series, followed by Gilbert Strang’s book and video lectures.
>
>
>
> > If people do not believe that mathematics is simple, it is only because they do not realize how complicated life is.
>
> — John von Neumann
>
>
>
> ### Operating Systems
>
> Operating System Concepts (the “Dinosaur book”) and Modern Operating Systems are the “classic” books on operating systems. Both have attracted criticism for their writing styles, and for being the 1000-page-long type of textbook that gets bits bolted onto it every few years to encourage purchasing of the “latest edition”.
>
> Operating Systems: Three Easy Pieces is a good alternative that’s freely available online. We particularly like the structure of the book and feel that the exercises are well worth doing.
>
> After OSTEP, we encourage you to explore the design decisions of specific operating systems, through “{OS name} Internals” style books such as Lion's commentary on Unix, The Design and Implementation of the FreeBSD Operating System, and Mac OS X Internals.
>
> A great way to consolidate your understanding of operating systems is to read the code of a small kernel and add features. A great choice is xv6, a port of Unix V6 to ANSI C and x86 maintained for a course at MIT. OSTEP has an appendix of potential xv6 labs full of great ideas for potential projects.
>
>
>
> [Operating Systems: Three Easy Pieces](https://teachyourselfcs.com//ostep.jpeg)
>
>
>
> ### Computer Networking
>
> Given that so much of software engineering is on web servers and clients, one of the most immediately valuable areas of computer science is computer networking. Our self-taught students who methodically study networking find that they finally understand terms, concepts and protocols they’d been surrounded by for years.
>
> Our favorite book on the topic is Computer Networking: A Top-Down Approach. The small projects and exercises in the book are well worth doing, and we particularly like the “Wireshark labs”, which they have generously provided online.
>
> For those who prefer video lectures, we suggest Stanford’s Introduction to Computer Networking course available on their MOOC platform Lagunita.
>
> The study of networking benefits more from projects than it does from small exercises. Some possible projects are: an HTTP server, a UDP-based chat app, a mini TCP stack, a proxy or load balancer, and a distributed hash table.
>
>
>
> > You can’t gaze in the crystal ball and see the future. What the Internet is going to be in the future is what society makes it.
>
> — Bob Kahn
>
> [Computer Networking: A Top-Down Approach](https://teachyourselfcs.com//top-down.jpg)
>
>
>
> ### Databases
>
> It takes more work to self-learn about database systems than it does with most other topics. It’s a relatively new (i.e. post 1970s) field of study with strong commercial incentives for ideas to stay behind closed doors. Additionally, many potentially excellent textbook authors have preferred to join or start companies instead.
>
> Given the circumstances, we encourage self-learners to generally avoid textbooks and start with the Spring 2015 recording of CS 186, Joe Hellerstein’s databases course at Berkeley, and to progress to reading papers after.
>
> One paper particularly worth mentioning for new students is “Architecture of a Database System”, which uniquely provides a high-level view of how relational database management systems (RDBMS) work. This will serve as a useful skeleton for further study.
>
> Readings in Database Systems, better known as the databases “Red Book”, is a collection of papers compiled and edited by Peter Bailis, Joe Hellerstein and Michael Stonebreaker. For those who have progressed beyond the level of the CS 186 content, the Red Book should be your next stop.
>
> If you insist on using an introductory textbook, we suggest Database Management Systems by Ramakrishnan and Gehrke. For more advanced students, Jim Gray’s classic Transaction Processing: Concepts and Techniques is worthwhile, but we don’t encourage using this as a first resource.
>
> (continues in next comment)
http://www.amazon.com/Modern-Operating-Systems-4th-Edition/dp/013359162X
You'll need to have some experience coding a few hundred lines and also have experience using a debugger. You'll also be expected to do readings which I highly recommend and the concepts are not that trivial; you'll need to wrap your head around concepts in 369 until it finally clicks. Implementing them in C isn't too bad, make good use of office hours and tutorials. Worst case scenario just get a good partner.
here's the textbook I was assigned, its a good read too: https://www.amazon.ca/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X
When you say you want to make a simplistic OS, do you mean you want to put together a simplistic Linux distro, or you want to code an OS from scratch?
In former case DSL might be your friend (Damn Small Linux):
http://www.damnsmalllinux.org/. There are other similar distros that might fit under 25 megabyte, google is your friend. As already mentioned by somebody else linuxfromscratch.org is another option. If you go with LFS, you want to look at minimal libraries instead of standard GNU libs for C library and standard system applications. For example you would like to get https://www.uclibc.org/ for c library (or some other similar, there are few) and say busybox https://www.busybox.net/ for your system apps. There other "micro" versions of some popular software (X server etc) which you might wish to consider if you are going completely custom route.
If I was you, I wouldn't do it, since many others have same thoughts as you and have already put effort and hours into making it, so why repeating all that work if you can just get a distro like DSL and install it and simply customize/change what you dislike. If you want it as an educational experience than certainly go for it, LFS might be very rewarding in that case.
If you want to code your own kernel and OS, than you might wish to take a CS class about OS:s, Tanenbaum is your eternal friend:
https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/ref=sr_1_1?ie=UTF8&qid=1498831929&sr=8-1&keywords=andrew+tanenbaum
https://www.amazon.com/Structured-Computer-Organization-Andrew-Tanenbaum/dp/0132916525/ref=sr_1_4?ie=UTF8&qid=1498831929&sr=8-4&keywords=andrew+tanenbaum
And don't forget Google ...
Modern Operating Systems
One of the best starter Comp Sci books.
Hit the books ! More specifically this one : https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X it’s a great book, it explains the concepts really well and also has code examples. Tho I recommend reading about computer architecture a bit to understand it better, this is also a great book for it https://www.amazon.com/Computer-Organization-Architecture-William-Stallings/dp/0134101618
But really read all of the tanenbaum’s book, I got an A because of it, it’s an amazing book.
The classics are generally the dinosaur book ( https://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720 ) or Tananbaum ( https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X ). Neither are terribly user friendly. Try /r/osdev -they're not hugely active but the sidebar resources should get you started.
When/if you get to the point where you want to learn more about multithreading, this is a good resource.
Modern Operating Systems (4th... https://www.amazon.com/dp/013359162X?ref=ppx_pop_mob_ap_share
Honestly I think you might learn more from this book:
https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X
https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X