Reddit mentions of The Linux Programming Interface: A Linux and UNIX System Programming Handbook

In short, the answer is virtual memory and the protected mode flat model that the past generations of CPU architecture and operating systems have been using.

As you may know, programs are never given full, direct access to the RAM banks; the operating system abstracts this layer away from them in the form of virtual memory. Virtual memory is basically a system whereby you can map physical memory addresses to non-physical ones the OS controls and can readily re-arrange. Thanks to virtual memory the OS can trick an application into thinking it has way more RAM than it actually has and this also enables swapping processes out to disk when the system is running out of memory because there are too many processes being run at the same time. As I pointed out before, since virtual memory is fully managed by the kernel, it can move out chunks of a program's address space to disk, a process known as "paging".

Now, back in the DOS era, virtual memory followed the real mode segmented model, which, in very simple terms meant that, even though processes could be shuffled back and forth between RAM and disk, there were no safeguards in place to prevent a process from messing up another process' memory space via a dodgy pointer pointing to a memory address beyond the scope of the faulty process.

One of the major goals of the successor to this virtual memory model, "protected mode flat model" was to allow the kernel to create a completely isolated address space for the processes it spawns and stopping a rogue program from altering other processes like before. Whenever such an attempt is made, a "segmentation fault" (SIGSEV) or "general protection fault" is raised by the kernel, which in the case of Linux, will prompt the kernel to swiftly kill the offending process.

In practical terms, this means your application won't be able to reach beyond the virtual memory address space it has been allocated (unless it's a kernel-space process, like a kernel subsystem or device driver) and can in no way communicate with other processes by reading or writing memory that belongs to them. In order to accomplish that, you'll need to make use of inter-process communication (IPC) techniques like Unix sockets, pipes, RPC, etc.

This is by no means an in-depth or 100% accurate explanation though. If you've got any follow-up questions I'm more than happy to answer them.

As for the literature, pretty much any textbook about operating system architecture will cover virtual memory to a great extent. I can recommend Operating Systems: Internals and Design Principles and Modern Operating Systems.

Here are a few more books that touch upon the topic of virtual memory:

Assembly Language Step-by-Step: Programming with Linux covers the topic of virtual memory and the different models that have evolved over time over its first few chapters.

The Linux Programming Interface: A Linux and UNIX System Programming Handbook covers this subject (and many, many more) from a Linux systems programmer perspective.

What Makes It Page?: The Windows 7 (x64) Virtual Memory Manager, in case you're interested in learning how Windows does it.

EDIT: added IPC info

What OS? Linux, of course. When TPB order everything locked down, you don't want to be caught using a Microsoft OS. -- What distribution? The easy path is Ubuntu, with the Cinnamon UI, or LinuxMint 13, when issued (May 2012).

What IDE? There's lots to choose from. My favorite is "geany".

https://en.wikipedia.org/wiki/Geany

For TCP/IP protocol tutorial. Recently updated by Wright:
Stevens, "TCP/IP Illustrated", 3-volume set.

http://www.amazon.com/TCP-IP-Illustrated-Volume-Set/dp/0201776316

On human interface guidelines relevant to programming:

https://en.wikipedia.org/wiki/Human_interface_guidelines

For GNOME 2, see:

http://library.gnome.org/devel/hig-book/stable/

To develop Linux applications:

You are right. You MUST know how to program in C. When others tell you that object oriented programming is the thing, know that you can do object oriented programming in C. Avoid interpreted languages (Python, Java, and others) as a first programming language. Interpreted languages teach bad habits and hid too much of what's going on from you such that debugging becomes difficult to impossible.

However, if all you intend is "casual programming", the Python will do, if you must. It's just not the best choice first a first language if your intent is to become a "professional programmer". I use Python myself; It works for what I need to do quick and dirty.

Definitive, but for experienced programmers:

http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1335197606&sr=1-1

As a tutorial for someone learning a first programming language and how to program from zero:

Perry, "Absolute Beginner's Guide to C", 2ed.
-- I have not read the book, but the ToC looks reasonable for a beginner.

http://www.amazon.com/Absolute-Beginners-Guide-2nd-Edition/dp/0672305100/ref=sr_1_6?s=books&ie=UTF8&qid=1335197606&sr=1-6

OK, you don't want a full CS curriculum, but some topics in discrete mathematics are mandatory. ... Ack! Having looked over the offerings at Amazon, I believe that Epp, "Discrete Mathematics with Applications" may be the best of the lot, but at $187, it is hard to recommend without knowing your intent and interest. The reason I suggest this title is that it looks focused on application to computer science topics. It covers a number of topics that are NOT covered in many of the other titles, enough so that should you use other texts you will have spent more than the $187 that this title includes. JMHO.

http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/ref=sr_1_1?s=books&ie=UTF8&qid=1335199316&sr=1-1

See also: Sedgwick, "Algorithms" -- You'll probably need it sooner than later.

http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?s=books&ie=UTF8&qid=1335200153&sr=1-1

Remember that Linux OS? You are going to need some programming tools, right? If you intend to write GUI applications based on the GTK+ toolkit, then install the package "glade" or "glade-gtk". Installing a glade package will suck in over 100 other packages essential to building a GTK based GUI application. Specifying glade to the package manager is just easier that finding and installing all the other necessary parts by hand.

If you are going to do command line based UI programs, then package "build-essentials" should be adequate.

There are some other things to read:

On how to organize, grow and maintain a Linux software development project: Fogel, "Producing Open Source Software"

http://producingoss.com/

You can read it online here, but buy the book too to help support Fogel. He's gotta eat too.

On the culture of writing Open Source Software:

Raymond, "The Cathedral and the Bazaar"

http://www.catb.org/~esr/writings/cathedral-bazaar/

Linux programming is not like Windows programming.
Read and study ESR's TAOP.

Raymond, "The Art of Unix Programming"

http://www.catb.org/~esr/writings/taoup/html/

You can read it online, free. However, buy a hardcopy too. Raymond has to eat too.

Now to get really technical. What interface do you write to?

Kerrick, "The Linux Programming Interface: A Linux and UNIX System Programming Handbook"

http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1335201257&sr=1-1#reader_1593272200

Beginning to focus on GNU style programming:

GNU Coding Standards

https://www.gnu.org/prep/standards/

GNU Coding Standards is more than how to and how much to indent a line or how to set braces. You will get into the topic of Make and Autotools. Make is a program to build complex softare and Autotools is about how to build a package for distribution, the package that any Unix flavor can use; it is not focused on any specific distribution. See also: "configure and make"

Enough! There's more, but I have too much time in this already for today.

[edit: typos]

I feel like C is most useful when you are programming directly to an OS and its resources, rather than through a framework or library. And you don't often need to use the most elegant data structures to accomplish a simple task.

The Linux Programming Interface is still one of the best introductions to Linux programming.

Linux Programming Interface (https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200)

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.

I've found The Linux Programming Interface to be one of the best in-depth books I've ever tried to read on Linux. Only issues with it is it's not too hands-on, so it's a bit difficult to retain, and maybe the price, bit would have to say it's still totally worth it.

I've heard good things about "The Linux Programming Interface"

"Modern Operating Systems" like others suggested is also fantastic.

I'd recommend reading Practical Programming: An Introduction to Computer Science Using Python. I would read each chapter two or three times, and supplement it with online help. Do all the exercises at the end. If you don't understand something, feel free to ask in compsci (or send me a private message!).

I always use this book when trying to teach someone the basics of programming. Python is very easy to learn, relevant, and powerful. The book is brief, well written, and it'll semi introduce you to the command line (which will become your best friend).

You should try and build yourself a Linux computer to learn programming on. If you have a mac, that would be an OK substitute. I would use windows as a last choice- it can be a decent development environment but requires lots of software to set up. Programming can certainly be done in windows, but Linux will offer you a decent development environment right out of the box. I'd recommend Ubuntu for beginners. Macs come with a lot of the same facilities that linux comes with (python and other languages pre-installed, a relevant command line environment, etc), windows comes with almost none. If you study computer science in college, you'll use lots of linux- a head start will help.

For a text editor, try and become familiar with vim or emacs, both of which come with most linux distros. If you find them too overwhelming, you could use a graphical editor instead and still be ok. On the mac, you can get macvim. As a programmer, I regret my lack of knowledge in vim. If you're on windows, just stick with something like notepad++.

If you become an ace at python, and really enjoy the concepts, The Linux Programming Interface will take you a (very) long way. It may seem overwhelming, but it covers many deep aspects of computing. Learning C will really help you the most in the long run (because of it's intimate relationship with the operating system and computer memory), but it is not an easy beginner language. If you don't understand the concepts in C (may be difficult from just a book), you may try your hands at either C# or Java (as they're both very widely used).

Keep in mind that no one becomes a programmer (or hacker, if you will) over night. I'm in CS grad school, and started programming over 5 years ago- it's just now starting to all make sense. The amount of conceptual information in computer science is tremendous, and it will take a long time to master. Welcome to the rabbit hole =)

P.S. - Learn to type the correct way without looking at the keyboard. Speed isn't that big of an issue so long as you can hit a consistent ~60 wpm.

you can start by grabbing The Linux Programming Interface book.

"Linux Kernel Development 3rd Edition" is fairly modern (2010) and really good:

http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=sr_1_1?ie=UTF8&qid=1413858907&sr=8-1&keywords=linux+kernel+development

Also... not kernel internals specific but an AMAZING book about programing against the linux kernel is "The Linux Programming Interface":

http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=pd_sim_b_4?ie=UTF8&refRID=1X9Y7ZM18JWKJ80PNXN3

It was written by the guy who wrote a lot of the linux man pages and is one of the best books about how linux works from a programming interface perspective that I've ever read.

The Linux Programming Interface, by Michael Kerrisk -- hands down the unsurpassed resource if you want to understand Linux.

To learn about the user space APIs
A good intro to the inner workings
A fairly detailed reference of the inner workings

Do start with C and then buy The Linux Programming Interface. Afterwards, I recommend buying a book dedicated to pthreads and another on sockets. Of course, do remember to do the actual exercises.

From gleaming at this content this is not aimed at programming. Try this: http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?ie=UTF8&qid=1418343920&sr=8-1&keywords=the+linux+programming+interface

Awesome book spotted under his desk at 2:45

Most books are still made out of paper.

Try these : UTLK
and Linux Programming Interface

You can't have it both ways. if you want to know exactly then you have to drill down to the fundamentals which are handled at a low level (C & assembly). If you want to understand the general concepts you'll need to make lateral moves and study CS along with having enough of the tiny details to fill in the gaps with your intuition.

I think what you may like is a book on the linux API. This is between kernelland and userland.

Try this one:

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200

Before you do that ensure you know enough basic C. Linux kernel uses K&R style. So this might be good enough and your best bet to fasttrack.

https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628

Do keep in mind this is 2K pages worth of reading. This should help to fill in enough of what you don't know you don't know so that you can better use google-fu to get you further.

You learned those from this book? Could you briefly explain them? I would like to learn more.

I think this is what you're looking for:
http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200

I'm not sure what book you're referring to. I can't seem to find it. If you're referring to this one: http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200 then I couldn't disagree more. That book is packed with TONS of useful information and examples everywhere. I've used a great deal of it. I can only assume you're talking about a different book or you didn't get very far.

What do you REALLY want to do? Because if you want to write systems level applications in C for Linux, you're not going to learn it overnight. It's going to take a lot of reading. You're not going to hop on codecademy, crank out a few tutorials and suddenly be good at it.

What's your background? What experience do you have? And again, what are you trying to accomplish, big picture?

I could be wrong but I read your post as "This book is TL;DR. I want a shortcut." There really aren't any for things like that.

If you must buy a book, start here: https://www.amazon.com/dp/1593272200/

I look up whatever I need in The Linux Programming Interface.
It’s exceptionally well written and covers a broad range of topics.
One of my favorite technical books ever.

Also, just read the manpages for Linux headers and syscalls.
Often they were written by the same author.

I'd make sure I have a really solid understanding of systems and networks, e.g. how Linux works. This book seems like a great overview and I love No Starch Press. There's also this book which is used by Carnegie Mellon's introductory systems course, though that might be a bit too deep to dive into straight away, more like something that could be used if you want a deeper understanding of how systems work. You should have some familiarity with C just as foundational knowledge. The guy who wrote Learn Python The Hard Way also wrote an intro to C, Learn C the Hard Way. He's added a lot more material than the last time I checked (~Dec 2012) which looks like it covers a lot of topics so it would be great to work through it.

Some more technical books on this subject that are well regarded and can be used as reference books are Advanced Programming in the Unix Environment, Unix Network Programming, and The Linux Programming Interface

Also in addition to Python I'd also suggest learning some Ruby (Practical Object-Oriented Design in Ruby and Programming Ruby 1.9 & 2.0 are two resources I'd recommend), it's what Chef is/was implemented in and is fairly nice to work with.

I know this is not specifically for kernel development, but The Linux Programing Interface Handbook is a great book for better understanding how to program for Linux systems.

C, C++, Assembly are best suited for the purpose. For managed code rootktis part, learn Java and/or .NET.

For Linux programming, have a look at (http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1450511098&sr=1-1&keywords=LINUX+Programming). In fact, this is a must read book IMHO. Apart from this, you can try these too:

1. http://www.amazon.com/Beginning-Linux-Programming-Neil-Matthew/dp/0470147628/ref=sr_1_2?s=books&ie=UTF8&qid=1450511098&sr=1-2&keywords=LINUX+Programming
   
   
2. http://www.amazon.com/Linux-System-Programming-Talking-Directly/dp/1449339530/ref=sr_1_4?s=books&ie=UTF8&qid=1450511098&sr=1-4&keywords=LINUX+Programming
   
   
3. http://www.amazon.com/Linux-Programming-Example-Arnold-Robbins/dp/0131429647/ref=sr_1_5?s=books&ie=UTF8&qid=1450511098&sr=1-5&keywords=LINUX+Programming
   
   EDIT: Formatting

Buy (/borrow/steal) The Linux Programming Interface by Michael Kerrisk. It's Stevens' APUE for the 21st century, and is well worth the price. Everything you can possibly do programmatically on Linux will be explained in detail there, including process management, threads, filesystems API, memory management, IPC, the Linux ABI, and so on.

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200

I have heard good things about The Linux Programming Interface but cannot verify it is as specific as you are looking for.

I think some of Julia Evans stuff is good for this.

For Linux internals read https://www.amazon.ca/Linux-Programming-Interface-System-Handbook/dp/1593272200 , you only need the intro to each chapter (before he gets to code).

For general Linux read https://www.amazon.ca/UNIX-Linux-System-Administration-Handbook/dp/0134277554/

You need to know some concepts very well, like life of a process and signals (may not pass initial screen interview without those), as well as basic networking (both google and facebook have a networking interview although it’s valued less than the others).

Btw there’s also an interview about designing a distributed systems, best source to learn is to read about tools at google, facebook and AWS.

For troubleshooting, there’s no book, it’s all practice with real problems. If I had the time or rather the priority, I’ll publish a bunch of broken things in docker containers as exercises but it’s a lot of work.

I do have a troubleshooting framework , with things like verify given information, trying to break the problem space in two , do first easy quick tests etc

My General Thought

I find it is best to learn and get exposure from several book/media sources coupled with actual application of things learned.

----

Introductory Texts/Links

Short Intro
http://heather.cs.ucdavis.edu/~matloff/unix.html

C Programming: A Modern Approach
http://knking.com/books/c2/index.html

Head First C (Different Presentation Style, check amazon preview)
http://www.amazon.com/Head-First-C-David-Griffiths/dp/1449399916/

Programming in C
http://www.amazon.com/Programming-C-4th-Developers-Library/dp/0321776410/

PDF Tutorial
http://phy.ntnu.edu.tw/~cchen/pdf/ctutor.pdf
Original Here > http://www.tutorialspoint.com/cprogramming/index.htm

C The HardWay (Mostly complete)
http://c.learncodethehardway.org/book/

Zed's K&R Critique
http://c.learncodethehardway.org/book/krcritique.html

Practical C Programming
http://shop.oreilly.com/product/9781565923065.do

Ben Klemens Modeling with Data book has a short C introductory section.
http://ben.klemens.org/pdfs/gsl_stats.pdf

-----

Reference
Harbison and Steele C Reference Manual
http://www.careferencemanual.com/

Plan on developing on Linux?
The Linux Programming Interface: A Linux and UNIX System Programming Handbook
http://www.amazon.com/dp/1593272200/

Didn't get Pointers?
http://www.amazon.com/dp/1449344186/

21st Century C, This book got dogged a lot, but I think its a nice text.
http://www.amazon.com/21st-Century-Tips-New-School/dp/1449327141

K&R Scan (If you want an idea what's inside K&R)
http://www.iups.org/media/meeting_minutes/C.pdf

-----

Need an Editor?
VIM Book
ftp://ftp.vim.org/pub/vim/doc/book/vimbook-OPL.pdf

Vim Video Tutorials
http://derekwyatt.org/vim/

-----

Back in the Day
I used these books years ago. They're somewhat dated, but still useful and cheap.
Programming in ANSI C
http://www.amazon.com/Programming-ANSI-Hayden-Books-library/dp/0672484080
Advanced C: Tips and Techniques (Hayden Books C Library)
http://www.amazon.com/Advanced-Techniques-Hayden-Books-Library/dp/067248417X/

----

C Language Basics
How do I read/write files
How things are implemented at a lower level
Compiler Options and Functionality
What is a make file?
Debugging... How to do it... How do I use a standard debugger like GDB?

As others have said, K&R is great for learning the C language. In addition to that, Algorithms in a Nutshell is a nice reference because it has sample code in C for a lot of major data structures and algorithms, so you can see how the language is used to implement CS concepts you might already be familiar with.

I would also highly recommend one or both of Advanced Programming in the Unix Environment or The Linux Programming Interface, which will get you up to speed on POSIX.

When I started, the most memorable three resources I know I had were the following:

• Bjarne's book - I don't think any C++ developer can truly call themselves even intermediate until they have absorbed at least half the content in the book. I started off with his 3rd edition, which is way less intimidating and shorter, but I subsequently ran through this entire book after it came out. There are no shortcuts on here - you need to read it.
  
• Effective C++ 3rd Edition - I would almost require this one as it prevents any new C++ developer from getting caught in C++ gotchas. You should ideally follow this book up with his 4th edition afterwords. The reason why I recommended the 3rd first is because that book is much more newbie friendly. The 4th edition is targeted towards experienced C++ developers that already have had their feet wet with C++11/14 and want to figure out some best practices. Note the 3rd edition is for C++98 while the 4th is for C++11/14.
  
  After you're done with the two above required books, here are some useful readings:
  
  
• What Every Programmer Should Know About Memory - This is an absolutely essential reading whether or not you've taken any systems courses. It's the foundation of what you will be programming towards (optimizing CPU cache usage).
  
• 1024cores - I believe this guy works/worked at Google at one point, but his site is essential to understanding multi-threaded programming (which is essential in the field). Browse through his site and learn what you can.
  
• Linux Kernel Development - Robert Love (who also works at Google) has probably written the most concise and understandable book on the Linux kernel I've ever read, and I've run through the Daniel Bovet's book and Michael Kirrisk's. For one thing, they're 1,000 and 1,500+ pages, respectively. Secondly, all I've found in those two books that I didn't find in Robert Love's is the implementation details in some areas as well as the details on the scheduler. Robert Love's incredible descriptions on the bottom-half/tasklets were already more than effective for normal understanding. I believe the latter books were more detailed in the networking areas as well, but in that case, you're better off with Understanding Linux Network Internals.
  
  The above readings will probably be a solid 6-12 months to read and absorb assuming you spend a couple hours a day, but I think it'll be well worth it in the long run since this type of stuff sticks with you for a long time. I read the above around 2013, and I can still talk about the CFS/other schedulers, software interrupts, and how the CPU cache works. It'll also make converting to other languages even more of a breeze because you'll know how everything works underneath the hood.

Have you taken a look at The Linux Programming Interface?

Thinking back on it now I think K&R C needs to be coupled with [the linux programming interface] (http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?ie=UTF8&qid=1411641367&sr=8-1&keywords=linux+programming+interface). It really helps flesh out the parts where K&R leaves you hanging. It also shows you the internals of c programs and much more.

I'm a fan of this book: http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200

It has way too much detail but it is organized well.

Yeah, the beauty of the low level libraries is they really do not change very much or often. I do not expect everyone to master them, but having an understanding will help in any area of userspace you work. Here are two great books that can be read with just an understanding of the c language.


http://www.amazon.com/The-Linux-Programming-Interface-Handbook/dp/1593272200/ref=sr_1_10?ie=UTF8&qid=1404953887&sr=8-10&keywords=linux


http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468/ref=pd_sim_b_1?ie=UTF8&refRID=10S29ZMT4Q5VQM4KYZRY

So there's this book called The Linux Programming Interface by Michael Kerrisk. Some consider it being the book.

Many people may disagree with me, but as a Linux user on the younger side of the spectrum, I have to say there was one thing that really worked for me to finally switch for good- books.

There's tons of wikis and forums and of course Reddit to ask questions, but it is hard to get good answers. You may end up paying for books (unless you look on the internet for books) but it doesn't beat having a hard copy in front of you. It boils down to a time vs money trade off. The only wiki I would follow is one directly from the developers that act as documentation, not a community wiki. Also worth nothing certain wikis are more tied to linux and the kernel than others, meaning some are comparable/interchangable with the distro you may be using. Still, a novice would not easily put this together.

Forums are also useless unless you have the configuration mentioned in the post or that forum curates tutorials from a specific build they showcase and you as a user decided to build your system to their specifications. There's way too many variables trying to follow online guides, some of which may be out of date.

This i've realized is very true with things like Iommu grouping and PCI Passthrough for kernel based virtual machines. At that point you start modifying in your root directory, things like your kernel booting parameters and what drivers or hardware you're gonna bind or unbind from your system. While that does boil down to having the right hardware, you have to know what you're digging into your kernel for if you dont follow a guide with the same exact parts that are being passthrough or the cpus or chipsets are different.

Books are especially handy when you have a borked system, like you're in a bash prompt or an initramfs prompt or grub and need to get into a bootable part of the system. Linux takes practice. Sometimes its easier to page through a book than to search through forums.

Another thing about being an intermediate or expert Linux user is that you don't care much about distros or what other users or communities do. It wont matter as under the hood it's all the same, spare the desktop and the package managers. Once you're out of that mentality you just care about getting whatever you want done. I'm not one of those guys that's super gung-ho FOSS and open source. I just use what gets the job done. Also from a security perspective, yes Linux is in theory MORE secure but anything can be hardened or left vulnerable. It's more configuration tied than many uses and forums or threads lead it on to be.

My workload involves talking to servers and quite a bit of programming and scripting, in a variety of capacities. That's what led me to linux over the competitors, but I'm not so prudent to never ever want to use the competitor again or have a computer with it. With understanding Linux more, I use it more as a tool than to be part of the philosophy or community, though that enthusiasm pushes for new developments in the kernel.

I'm assuming you're a novice but comfortable enough in linux to get through certain things:

In any computer related thing, always TEST a deployment or feature first- From your linux system, use KVM or Virtualbox/vmware to spin up a few linux VMs, could even be a copy of your current image. This way any tweaks or things you want to test or try out is in an environment you can start over in.

The quickest way to "intermediate-expert" Linux IMO is learning system administration.

My go to book for this is "The Unix and Linux System Administration Handbook 5th edition"

https://www.amazon.com/UNIX-Linux-System-Administration-Handbook/dp/0134277554/ref=sr_1_1?keywords=The+Unix+and+Linux+System+Administration+Handbook+5th+edition&qid=1564448656&s=books&sr=1-1

This edition is updated recently to cover newer kernel features such as could environments and virtualization. This book also helps when learning BSD based stuff such as MacOS or FreeBSD.

Another good read for a "quick and dirty" understanding of Linux is "Linux Basics for Hackers" It does focus on a very niche distro and talks about tools that are not on all Linux systems BUT it does a good concise overview of intermediate things related to Linux (despite being called a beginners book).

https://www.amazon.com/Linux-Basics-Hackers-Networking-Scripting/dp/1593278551/ref=sr_1_3?crid=396AV036T1Y0Q&keywords=linux+basics+for+hackers&qid=1564448845&s=books&sprefix=linux+bas%2Cstripbooks%2C119&sr=1-3

There's also "How Linux works" but I cannot vouch for this book from personal use, I see it posted across various threads often. Never read this particular one myself.

https://www.amazon.com/How-Linux-Works-2nd-Superuser/dp/1593275676/ref=pd_bxgy_14_img_2/137-6604082-4373447?_encoding=UTF8&pd_rd_i=1593275676&pd_rd_r=feffef24-d3c3-400d-a807-24d8fa39cd1e&pd_rd_w=8GX0o&pd_rd_wg=3AMRB&pf_rd_p=a2006322-0bc0-4db9-a08e-d168c18ce6f0&pf_rd_r=WBQKPADCVSABMCMSRRA1&psc=1&refRID=WBQKPADCVSABMCMSRRA1

​

If you want a more programming oriented approach, if you're confortable with the C language, then you can always look at these books:

The Linux Programming Interface

https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=zg_bs_3866_1?_encoding=UTF8&psc=1&refRID=5YN3316W22YQ4TSMM967

Unix Network Programming VOL 1.

https://www.amazon.com/Unix-Network-Programming-Sockets-Networking/dp/0131411551/ref=sr_1_1?keywords=Unix+Network+Programming+VOL+1.&qid=1564448362&s=books&sr=1-1

Advanced Programming in the Unix Environment

https://www.amazon.com/Advanced-Programming-UNIX-Environment-3rd/dp/0321637739/ref=zg_bs_3866_2?_encoding=UTF8&psc=1&refRID=5YN3316W22YQ4TSMM967

These books would take you to understanding the kernel level processes and make your own and modify your own system.

As many have mentioned, you can go into these things with "Linux from scratch" but it's also feasible to do Linux from scratch by copy/pasting commands. Unless you tinker and fail at certain things (hence do it on a vm before doing it to the main system) you won't learn properly. I think the sysadmin approach is "safer" of the two options but to each their own.

You may want to check out this book: The Linux Programming Interface: A Linux and UNIX System Programming Handbook

This is called "Learn C the Hard Way," but I think a better name is "C Programming for Idiots." Just dive in with the real stuff.

http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?ie=UTF8&qid=1317921424&sr=8-1

http://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?s=books&ie=UTF8&qid=1317921571&sr=1-1