See this, from one of the authors of one of the best undergraduate textbooks on operating systems:

• The Case for Free Online Books (FOBs): Experiences with "Operating Systems: Three Easy Pieces" by Remzi Arpaci-Dusseau, http://from-a-to-remzi.blogspot.com/2014/01/the-case-for-fre...

This looks great!

I would also like to recommend another free resource that might be a good complement(theory vs implementation) to this:

"Operating Systems: Three Easy Pieces"

available online at:

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

Operating Systems at Bard College, a decidedly not top tier CS school but I still learned a fair bit :)

The materials, as far as I know, are not available online. But we used Tannenbaum's book which you can read for free here - http://stst.elia.pub.ro/news/SO/Modern%20Operating%20System%...

Enjoy!

I love his Operating Systems book [0] which explains OS Concepts using Minix code

[0] - http://www.amazon.com/dp/0131429388

Tanenbaum's Operating Systems isn't there. Sorry, this isn't a good list.

/fanboy

> Tanenbaum's Modern Operating Systems

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

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

I recently bought Operating Systems: Three Easy Pieces after hearing good things about it. Didn't really have time to go through it yet, but it does seem interesting. There's also a free PDF version.

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

1. Operating systems : three easy pieces

2. Computer network a top down approach

3. Electric Machinery Fundamentals

Each book teaches what the book is intended to and in a really comprehensive manner.

When I saw "Operating Systems: Three Easy Pieces" I thought... the shell, the file system and the kernel. And if you know what I mean by that, then you, too, are old.

"Operating Systems: Three Easy Pieces

Remzi H Arpaci-Dusseau, Andrea C Arpaci-Dusseau"

It is by one of the coauthors of the Hennessy and Patterson book and it is uptodate, well written and free.

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

The book's page also has links to other interesting books on operating systems and lobsters (sic).

The author's teaching page links to excellent undergraduate and graduate level OS material.

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

It was 1995... so the Comp Org was Tanenbaum's Structured Computer Organization. I also used his Operating Systems book in the OS class. I thought they were excellent but I also had great profs.

I'll try to find my theory of computation text so I can see who wrote that, but again that was a great prof that walked through it really well.

Alas my bias against lisp may solely be traced to the Programming Languages prof that loved Scheme but couldn't actually communicate with humans. He could recite pi to 100 decimal places and was esteemed as brilliant but literally couldn't form sentences when talking to students. I suspect the lambda calculus would have been a good insight as well, but oh well.

"Operating Systems: Three Easy Pieces" is a more modern book to OS concepts, explained with real source code as opposed to algorithms, and is regularly updated.

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

(Online version above, you can also order a print copy).

Memory allocated in variable sized chunks has a lot more fragmentation. The OS would have to search around for free areas and keep track of them to be able to give memory out. Although, this is what user space allocators already do.

The book Operating Systems: Three Easy Pieces has a section to answer this very question.

Related and similar: See also the blog post (“Why Textbooks Should Be Free”) “The Case for Free Online Books”[1] by Remzi Arpaci-Dusseau, professor at Wisconsin and (co-)author of the fantastic Operating Systems book “Operating Systems: Three Easy Pieces” (http://www.ostep.org/)

[1]: http://from-a-to-remzi.blogspot.com/2014/01/the-case-for-fre...

What worked for me is trying to develop my own kernel. This might be too low-level for you, but it helps immensely to dispel the magic around how code gets executed by the CPU and the OS. You'll learn how the OS achieves protection from user programs, what are interrupts and how does the OS handle them, what are processes and threads and how does the OS schedule their execution, how virtual memory works (segmentation/paging), how the program is laid out in memory (code, data, heap, stack), how runtimes like the C runtime manages memory and links your code to OS syscalls, how dynamic linking works, what is an ABI, what is a calling convention, how does the compiler, the linker, and the OS know what each should do? How memory mapped file access works, etc. I can keep going, but you get the picture.

From there, you'll know where to go next based on what you've learned so far.

My recommended reading list is:

[1] Operating Systems: Three Easy Pieces https://pages.cs.wisc.edu/~remzi/OSTEP

[2] Intel Software Developer Manuals (especially volume 1 and 3A) https://software.intel.com/content/www/us/en/develop/article...

[3] OSDev wiki https://wiki.osdev.org

All the three books you've listed focus on APIs and code. It's also useful to know what's going on in the machine so that these APIs can be understood more easily.

The "Operating Systems - Three Easy Pieces" is one great book that has already been mentioned. I would also suggest "Computer Systems - A Programmer's Perspective" along the same lines (https://csapp.cs.cmu.edu/).

Computer Networking is another field you're likely to run into. "Computer Networks: A Systems Approach" is a good book (https://book.systemsapproach.org/)

Computer Systems: A Programmer's Perspective: around 2012 / 2013, I went through this book because I took a coursera course based on it. In fact, many universities base their systems courses around this book. It is really well written, has a great choice of topics, and phenomenal exercises [0] for practice (some are legitimately fun).

Operating Systems: Three Easy Pieces: In 2013, I found this book because I was frustrated with the textbook assigned for my operating systems class (Silberchatz). OSTEP has incredibly clear and concise descriptions without skimping on necessary details. It's wonderfully written. I was so jazzed up about this book that I ended up sending a lot of edits / improvements, and the authors gave me a very kind shoutout in the acknowledgements section.

Computer Networking: A Top-Down Approach: In 2013, this was the assigned textbook for my computer networking class. I already owned Tanenbaum & Wetherall which is good, but preferred this book. It is a more approachable treatment of networking (without sacrificing any crucial topics), so better for a first course.

I've heard glowing reviews of The Algorithm Design Manual, Designing Data-Intensive Applications, and Structure and Interpretation of Computer Programs over the years, but I haven't personally gone through them. For the TeachYourselfCS categories that I know the textbook landscape, I find their selections spot-on and pretty refreshing.

[0] https://csapp.cs.cmu.edu/3e/labs.html

For those readers that are curious who Tannenbaum is, he wrote (the best IMHO) operating systems book [0]. This book contained the complete source of an operating system 'Minix'. At the same time Torvalds wanted to build a OS system. Did Torvalds use/steal or extend the Minix source? It is extremely controversial [1] amount CS types.

https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanen... [0]

http://wiki.c2.com/?MinixOperatingSystem [1]

I bought Operating Systems: Three Easy Pieces in hardcover from Lulu.

http://www.lulu.com/shop/http://www.lulu.com/shop/remzi-arpa...

The book is over 700 pages. It's very nicely done. The front and back covers are just the right thickness. The book is not bound in signatures, it's edge glued ("perfect bound") like a paperback. But, the spine is extremely flexible and not attached to the casing. I was very careful to open it properly by gently creasing down sections of pages starting at the front and the back. If this is not done, there is risk of breaking the spine. I can open the book at any page and it lies flat on the table. The paper is medium weight, light ivory, and non-glossy. The casing is printed nicely with the title, and the dust jacket is first rate. Altogether, I'm quite pleased.

During the pandemic, I found myself unemployed with mountains of free time.

I knew I specifically wanted to dig into minix as a pastime. In my mind, the text book(s), and a fully featured Unix with a small code base were a unique combination...

That is, until I sat down to actually buy the book. The $200 price tag was beyond sticker shock. It was literally offensive.

I didn’t take long to find Operating Systems: Three Easy Pieces (OSTEP)[1]. The book can be had for Legally FREE or Affordable. And the introduction contained (among everything else) a brief manifesto admonishing the crazy high prices of college text books.

The book is funny, technically excellent, and also features a tiny-sized Unix like operating system: xv6.

Pouring my hours into this book and learning the XV6 operating system was time well spent.

[1]: https://pages.cs.wisc.edu/~remzi/OSTEP/?source=techstories.o...

All those technologies will be gone in less than a decade. Learn fundamentals, don't worry about the current trends. Here's a good starting point: https://columbia.github.io/ds1-class/. I've also found "Operating Systems: Three Easy Pieces" to be surprisingly relevant to system design: https://pages.cs.wisc.edu/~remzi/OSTEP/?source=techstories.o....

I agree with the Operating Systems Three Easy Pieces textbook. It was used in one of my courses in college and even as a bad dev then, it made me appreciate a lot of things I take for granted, as well as C. Although once I got to the scheduler, mutexes, etc I lost interest haha. But making my oen linked list was a very fun exercise.

I think what you gain by reading is exposure to someone else's way of thinking. You won't get that by sitting in a vacuum. If you're impressionable, you just assimilate the author's way of thinking without any criticism. That shouldn't be the goal here.

The key part of that quote (whether it's real or not) is the "and uses his own brain too little" part. It's not as helpful to read a book mindlessly like you're watching television and I think you're missing out on so much by just reading technical manuals. You need to form your own opinion about what you're reading by drawing on your own experience and things you've learned.

I'm pretty sure you didn't develop your way of thinking by yourself. You were influenced by mentors and other people's thoughts and opinions. So why would you intentionally stop evolving? How do you know you've reached some "optimal mental state"?

As an aside, if you're into well-written technical books that are enjoyable to read, check out Operating Systems: Three Easy Pieces:
http://pages.cs.wisc.edu/~remzi/OSTEP/

Operating Systems: Three Easy Pieces[0] coupled with Xv6[1].

Once you understand the fundamental ideas, you can move on to a specific real world implementation like The Design and Implementation of the FreeBSD Operating System by Marshall Kirk McKusick et. al or Linux Kernel Development by Robert Love.

[0]: http://pages.cs.wisc.edu/~remzi/OSTEP/

[1]: https://pdos.csail.mit.edu/6.828/2012/xv6.html

One approach to getting a list of topics is to look at the degree requirements for a couple of universities. I'm wrapping up a similar project, and here's what I included, along with some resources I used:

* Algorithms (CLRS, Skiena)

* Databases (db-class.org, any text by C.J. Date)

* Probability, Statistics, and Combinatorics

* Programming Languages (I liked Grossman's course on Coursera)

* Linear Algebra (http://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebr...)

* Natural Language Processing (Coursera has several courses)

* Machine Learning/Information Retrieval/Data Mining (I used a couple books, Mining Massive Datasets and Data-Intensive Text Processing with MapReduce being the two I'd recommend)

* Networking (Coursera has a good course)

* Operating Systems (https://www.youtube.com/watch?v=XgQo4JkN4Bw&list=PL62A66DDD3...)

* Distributed Systems (I read Tanenbaum's book)

* Computability

I'd suggest "Operating Systems: Three Easy Pieces". (http://pages.cs.wisc.edu/~remzi/OSTEP/)

I've found it very accessible. Largely, the way that they teach is to describe a system based on a set of assumptions, then slowly relax each of the assumptions one by one until you reach an example of a real system. That style of teaching really works for me.

First off, don't worry. You already have all the necessary tools you need.

Although the language you use to learn system & network programming doesn't matter much, it is better if you use C or C++ to practise and learn. This is because the kernel itself is written in C and exposes system calls that can be used directly from a C/C++ program. That said, "The Linux Programming Interface"(I am personally reading it) is a really good book. It talks a lot about how one should go about using system calls to get things done by the kernel. Make sure to read a little every day and try out the examples by writing C/C++ programs.

I recently realized that TLPI doesn't talk much about why are things the way they are(a very good example would be virtual memory and related stuff). You should refer some theoretical book for this. I suggest you go with "Operating systems" by Deitel & Choffnes.

Read man pages and practise using the libc/kernel APIs. For example, if you want to know about flushing, read 'man 3 fflush'. This might be needed when you want to flush all the input/output data that has been buffered by the C library before you can get fresh input from stdin. For example, if prompts are buffered, you definitely don't want to "scanf" before you have flushed the buffers. If you want to learn network programming, read chapters related to socket and refer 'man 2 socket'.

You will eventually get to a point where you will be able to connect all the dots(APIs) and be able to figure out what exactly you will need to get some problem solved.

Finally, don't learn for a future job. Learn for yourself. This will help you in the long run.

I love "Operating Systems: Three Easy Pieces":

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

Really useful book and really accessible (both because it's available for free and also because it's written with a lot of skill and friendliness towards the reader).

I recommend it in particular to those who for whatever reason never took an operating systems class (e.g., you were self-taught or didn't major in CS). This book will really demystify a lot of stuff for you without overwhelming you at the same time.

I am still in my first year of programming and Rust is my first systems language. I don't know C++, just enough for 'gists'. I had already read/skimmed Computer Organisation and Design: RISC-V, and Operating Systems: Three Easy Pieces. I worked through 'The 2018 Rust Book' at a fairly decent clip as a result of that context. I reckon that mostly sidesteps the 'help/hinder' tradeoff, though I'm not humble in saying it took a fair bit of dedication (maybe more than simply learning C++ fundamentals).

Edit: actually I'm well into my second year of programming now, time flies...

I started learning kernel internals from these books, I highly recommend all of them.

Operating Systems: Three Easy Pieces (free online) - Arpaci-Dusseau

Linux Device Drivers, 3rd ed (o'Reilly) - Jonathan Corbet

The Linux Programming Interface - Michael Kerrisk

The Design and Implementation of the FreeBSD Operating System (2nd ed) - McKusick, McKusick, Watson

Solaris Internals - McDougall, Richard, Mauro

Looks like you haven't even started thinking about the problems you'll run into architecting the actual mechanisms and policies of the operating system; process scheduling, virtual memory, etc. That's probably for the better—one thing at a time. For when you do get to that stage, I recommend Operating Systems: Three Easy Pieces. http://pages.cs.wisc.edu/~remzi/OSTEP/

Operating Systems (3rd Edition), Deitel -- is an excellent way to fill in gaps in your understanding of the OS. Don't buy it new -- used copies can be found on amazon for less than $20.

Learn a radically different programming language: Common Lisp.

Seibel's Practical Common Lisp is a very good introduction -- Keene's Object-Oriented Programming in Common Lisp will give you a wildly different way of looking at OO -- The Art of the Metaobject Protocol will forever change any preconceived notions you might have regarding objects.

Probably not. I say this not to discourage you from writing, but to prompt you to write a book that does something -- a book worthy of fundamental disagreement and passionate debate.

Operating Systems: Three Easy Pieces [1] covers the really interesting parts of the book you are considering, and skips the parts that can't really be given decent treatment: x86 Assembly, C, and writing a toy operating system. Likewise, Linux from Scratch covers understanding the practical side of Operating Systems [2].

A book I want to read has "EMACS really is an operating system" as it's thesis and then proceeds to show why and how our concept of operating system covers it -- a book that challenges our comfort in distinguishing operating systems.

Another book I want is "Build an Operating System for $3.47 worth of Breadboarded Chips." There's a book which pushes the lower bounds of computing. Something that provides fertile ground for new ideas.

Write a book at the edges, in the space between computer science curricula and actual practice. Write it just for people who are interested in operating systems. Write it for skimmers and strugglers and dilettantes and professionals. Write it so that people will learn, but also so that some will disagree on conceptual [rather than technical] grounds.

Then it might find a niche.

Good luck.

[1] http://pages.cs.wisc.edu/~remzi/OSTEP/

[2] http://www.linuxfromscratch.org/

The old standards.

Stevens to start. If you don't already know Stevens' thoroughly first, I wouldn't go deeper. The kernel is not separable from the userland-facing API.

I'm not convinced you actually need to / want to understand actual internals. But assuming you do, next is Tanenbaum (maybe start with the newer "Modern" book).

"Operating Systems: Three Easy Pieces" also seems well regarded, although I haven't read it myself.

The FreeBSD book is great, if you're specifically interested in BSD. There's also a video lecture you can buy on McKusick's site. I had the pleasure of an on-site presentation and it is absolutely fantastic.

From "Operating Systems: Three Easy Pieces" chapter on "Process API" (section 5.4 "Why? Motivating The API") [1]:

    ... the separation of fork() and exec() is essential in building a UNIX shell,
    because it lets the shell run code after the call to fork() but before the call
    to exec(); this code can alter the environment of the about-to-be-run program,
    and thus enables a variety of interesting features to be readily built.

    ...

    The separation of fork() and exec() allows the shell to do a whole bunch of
    useful things rather easily. For example:

      prompt> wc p3.c > newfile.txt
    
    In the example above, the output of the program wc is redirected into the output
    file newfile.txt (the greater-than sign is how said redirection is indicated).
    The way the shell accomplishes this task is quite simple: when the child is
    created, before calling exec(), the shell closes standard output and opens the
    file newfile.txt. By doing so, any output from the soon-to-be-running program wc
    are sent to the file instead of the screen.

[1] https://pages.cs.wisc.edu/~remzi/OSTEP/cpu-api.pdf

During the past six months I have been challenged intellectually and aesthetically by these works:

Paideia: The Ideals of Greek Culture, vol 1-3, by Werner Jaeger

Diary by Witold Gombrowicz

Computer Science: An Interdisciplinary Approach by Sedgewick

2666 by Roberto Bolaño

The Linux Programming Interface by Michael Kerrisk

Tomie: No Use Escaping by Junji Ito

L’homme aux cercles by Fred Vargas

Cryptonomicon by Neal Stephenson

Lab Girl by Hope Jahren

Operating Systems: Three Easy Pieces by Arpaci-Dusseau

I Contain Multitudes by Ed Yong.

The Weird by Ann and Jeff VanderMeer

The Federalist Papers, ed. by Kesler

The Anti-Federalist Papers, ed. by Ketcham

Doctor Faustus by Thomas Mann, new translation by John Woods

Searching for Stars on an Island in Maine by Alan Lightman

Loren Eiseley in the Library of America Edition

Tu rostro mañana by Javier Marías

The Complete Essays by Michel De Montaigne, translation by Screech

Earning The Rockies by Kaplan

Desperate Remedies by Thomas Hardy

The Notebooks of Joseph Joubert

Nature Stories by Jules Renard

Mac y su contratiempo by Enrique Vila-Matas

Olinger Stories by John Updike

Greek Science in Antiquity by Marshall Clagett

At The Existentialist Cafe by Sarah Bakewell

100 Diagrams That Changed The World by Scott Christianson

Heart of Europe: A History of the Holy Roman Empire by Peter Wilson

Alec "The Years Have Pants" by Eddie Campbell

Landmarks by Robert Macfarlane

There are two books that taught me how systems work.

- One system in isolation - Operating Systems: Three Easy Pieces. Covers persistence, virtualisation and concurrency. This book is available for free at https://pages.cs.wisc.edu/~remzi/OSTEP/

- Multiple systems, and how data flows through them - Designing Data Intensive Applications. Covers the low level details of how databases persist data to disk and how multiple nodes coordinate with each other. If you’ve heard of the “CAP theorem”, this is the source to learn it from. Worth every penny.

More on why these two books are worth reading at https://teachyourselfcs.com

OS security is something that really aught to be discussed separately from OS texts. I mean, not all OSes are multiprogramming or need security. Earlier version of his Operating Systems book taught MS DOS, along with others, for example.

Security exposition is something best left to a separate text, and Matt Bishop's fat book does a good job (not the thin watered down one.)

I'm not sure how you could squeeze the education I got into 10 months, but I think, properly motivated and with good books, you could self-study an equivalent to a solid BS in 18-24 months.

Topics that come to mind (that my CS bachelors had):

Boolean algebra and gate level stuff (one semester)

Calculus and Linear Algebra (this totaled 4 semesters)

Discrete Math (had one semester on this)

Fairly deep knowledge of at least one traditional language and at least one functional language (as part of other classes)

Basic computing theory (DFA/NFA/Regex/Push-down Automata/Grammars/Turing Machines)

Data structures (the more the merrier)

Algorithms and algorithm analysis (had three semesters on this)

AI (lots of interesting stuff is happening here, and AI is totally not what you think it is)

Architecture and Assembly (had two semesters in this area)

Operating Systems and Assembly (two semesters)

Compilers and other practice at large engineering tasks with programming languages

If you search over at searchyc.com, you'll find the topic of good CS books has come up here over and over. You'll find lots of good reads in those threads.

If you want to go out and try some more mathematical approach use the exercises on http://projecteuler.net/ to improve a little on the math side

If you want to understand what the computers does and on what level you just need to start reading books or going to courses

Books about algorithms and data structures (Cormen et al)
Any book introductory to Operating Systems is a must (Tanenbaum or Silberschatz operating systems)