For serious developers wanting to understand Linux at the kernel level, these books stand out:

// Example of kernel module code from "Linux Device Drivers" book:
#include 
#include 
MODULE_LICENSE("Dual BSD/GPL");

static int hello_init(void) {
    printk(KERN_ALERT "Hello, world\n");
    return 0;
}

static void hello_exit(void) {
    printk(KERN_ALERT "Goodbye, cruel world\n");
}

module_init(hello_init);
module_exit(hello_exit);

The Linux man-pages project (man7.org) provides the most authoritative technical reference. Key sections:

• man 2 syscalls - System call documentation
• man 7 socket - Network programming interfaces
• man 5 proc - /proc filesystem details

Linux Journey (linuxjourney.com) offers hands-on terminal exercises. For example, their filesystem tutorial includes:

$ sudo debugfs /dev/sda1
debugfs: ls -l
debugfs: stat 
debugfs: quit

YouTube channels like "The Linux Foundation" provide conference recordings about:

• Memory management internals
• Filesystem architecture
• Containerization mechanics

Use these commands to study the kernel source:

$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
$ cscope -R -b -s /usr/src/linux-headers-$(uname -r)
$ ./scripts/tags.sh

Learn system internals through debugging:

$ strace -f -o trace.log ls -l
$ ltrace -S -n 2 ./myprogram
$ perf stat -e instructions,cache-misses ls

As a daily Linux user transitioning from casual to professional usage, understanding the OS internals becomes crucial for system programming, DevOps, and performance optimization. Let me share resources that helped me bridge this gap.

The Linux Programming Interface by Michael Kerrisk (No Starch Press) remains the definitive guide. For example, this POSIX thread creation code demonstrates its practical depth:

#include 
#include 

void* thread_function(void* arg) {
    printf("Thread ID: %ld\n", (long)pthread_self());
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL);
    return 0;
}

Linux Kernel Documentation (kernel.org/doc) provides unparalleled insight into subsystems. The Linux Insides GitHub book (0xAX.gitbooks.io/linux-insides) explains boot process through system calls with code examples like this x86_64 assembly for sys_write:

mov $1, %rax    ; syscall number for write
mov $1, %rdi    ; file descriptor (stdout)
mov $message, %rsi
mov $len, %rdx
syscall

OverTheWire's Bandit wargame teaches file permissions and process monitoring through practical challenges. For instance, Level 5 requires finding a file with specific permissions:

find / -user bandit6 -group bandit5 -size 33c 2>/dev/null

For those interested in kernel hacking, Linux Kernel Development by Robert Love and kernelnewbies.org provide hands-on guides. Here's a basic kernel module template:

#include 
#include 

int init_module(void) {
    printk(KERN_INFO "Module loaded\n");
    return 0;
}

void cleanup_module(void) {
    printk(KERN_INFO "Module unloaded\n");
}

MODULE_LICENSE("GPL");

The Linux Documentation Project (tldp.org) contains advanced HOWTOs like configuring iptables:

iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -j DROP

Master perf(1) for CPU profiling. This command samples stack traces at 99Hz:

perf record -F 99 -ag -- sleep 10
perf report --stdio