Reddit reviews Principles of Operating Systems: Design and Applications (Advanced Topics)

For the nitty-gritty details, the OSDev wiki is very helpful.

This tutorial on writing an OS in Rust was pretty useful when starting out with the bare-bones basics of a 64-bit kernel. The OSDev wiki tutorials can some times be out-of-date on some things, so this was a useful resource.

For the more higher-level concepts, a standard OS textbook should do. I used the Silberchatz "dinosaur book" in my OS class, and it's fine, but I definitely felt like it focused on the higher-level concepts with an omission of lower-level implementation details.

On the other hand, there is something of a whole "subgenre" of OS books that cover one OS kernel in excruciating, often line-by-line detail, which can be very useful for seeing how to apply those concepts from the higher-level textbooks. The "original" in this subgenre was John Lions's commentary on sixth edition UNIX from the 1970s. Some of the low-level hardware concepts apply to the PDP-11 back in the day, but a lot of the details are still applicable today. There's also the xv6 kernel teaching kernel from MIT, which is just the sixth edition UNIX re-implemented for x86 processors, with an accompanying book/commentary. Some other books in this genre I've read are Notes on the Plan 9 Third Edition Kernel Source (non-ideal) or the one a professor at my university wrote, Principles of Operating Systems, which covers Linux and the Inferno operating system.

Hopefully that gives some useful places to start.

As others have mentioned, trying to use Vim as an IDE is thinking about the problem or Vim in an inverse manner that will lead to frustration. The Acme Text Editor's model for composing tools to form an IDE is exactly how one uses Vim most effectively.

A concrete Vim specific example is programming Go in Vim: VimGo. Note how in the context of Go instead of subsuming the functionality of external tools, the external tools are instead leveraged and exposed through an interface or accessed through existing Vim functionality.

That is exactly how to wield Vim and external tools masterfully and with the most efficacy. The Unix as an IDE articles discuss this concept in depth also and are excellent. Separation of concerns is precisely how all tools should be designed, something which Plan 9 and Inferno OS display masterfully and irrefutably; note how well done, completely encapsulated abstractions enable a completely composable environment as a result, brilliant no?

That same pursuit is realized through the Go toolchain, much of Haskell, and increasingly through the Clang toolchain, which is very powerful and very freeing to create great, completely optimized workflows.

If you really want to grok the mindset and approach to wielding external tools effectively and why tools must be designed this way for maximum workflow efficacy, I highly recommend reading and understanding the literature written by Brian Stuart's Principles of Operating Systems: Design and Applications that covers Inferno OS's design very well, and W. Richard Stevens' Advanced Programming in the UNIX Environment, the latter of which is a classic CS text and very lucid. Cat-V has a lot of great articles which discuss various tools as well.

The workflows enabled through the UNIX Philosophy is so much more effecient that even when outside a UNIX environment I utilize the tools through a VM rather than being hamstrung in an environment which eschews that design completely.

And because these tools are ubiquitous I can avoid relearning how to accomplish the same thing over and over as a result, meaning that the initial opportunity cost is worthwhile in the long run. Linux is increasingly incorporating features in the kernel which improve upon previous implementations as well as in user space, so it is an exciting time for system programmers as well as other programmers.