The Runtime Theory
Operating SystemsIn production

File Systems Explained

Recording in progress
#file-systems#storage#ext4#linux

A file is a convenience: the disk is a pile of sectors, and something has to organize them into names, sizes, and metadata. This video walks through the data structures that do that — the superblock, inodes, directories, and free-space tracking — and follows one write() from your process through the page cache to the disk platter.

Topics covered:

  • The block layer: why disks are addressed in 4KB units, not bytes
  • Inodes: where size, timestamps, and block pointers live
  • Directories: name-to-inode mappings, not files themselves
  • Extents and why modern file systems avoid per-block pointers
  • The page cache and delayed allocation: how writes become lazy
  • Journaling: the log that keeps metadata consistent across crashes
  • Hard links vs. symlinks and what rm actually removes
  • Why fsync is the cost you pay for durability

Related articles

operating systems

The OOM Killer and Memory Pressure: Who Dies and Why

When reclaim fails, the kernel executes: how oom_score picks the victim, why overcommit makes malloc lie, and why killing innocent processes is a feature, not a bug.

4 min readRead
operating systems

cgroups and Container Isolation: Why Docker Is Not a VM

Namespaces change what a container sees; cgroups control what it gets — CPU shares, memory limits, the freezer — and the shared-kernel security reality behind Docker.

3 min readRead
operating systems

What Really Happens During a System Call

Trap, ring transition, and the syscall table — the cost of asking the kernel for help and why it's never free.

5 min readRead

More in Operating Systems

19:20
operating systems

Virtual Memory in One Diagram

Page tables, TLB, demand paging, and copy-on-write — how your 16GB laptop 'has' 128GB of addressable memory.

Watch
In production
operating systems

Container Isolation in Linux

What Docker and Kubernetes containers actually are — namespaces, cgroups, and the syscalls that make isolated processes without a VM.

Details
In production
operating systems

Signals and Interrupts

Hardware interrupts and Unix signals — the two asynchronous mechanisms that interrupt your program, and what the kernel does between the wire and your handler.

Details
In production
operating systems

Locks and Synchronization Primitives

Mutexes, spinlocks, semaphores, and condition variables — how they map to hardware atomics and futexes, and when each one is the right tool.

Details
In production
operating systems

Memory-Mapped Files

How mmap() maps a file into your address space — demand paging from disk, the page cache, and why mapped I/O beats read() and write().

Details
In production
operating systems

Thread Pools Explained

How thread pools work under the hood — worker threads, work queues, and why reusing threads beats spawning them for every request.

Details
In production
operating systems

Syscalls Under the Hood

What actually happens when your program calls read(), open(), or fork() — the trap, the kernel mode switch, and the return path.

Details
In production
operating systems

Virtual Memory Explained

Address translation, page tables, and the TLB — the full path from a virtual address to the physical RAM cell, including why the translation is cached.

Details
In production
operating systems

Process Scheduling, Visualized

How the Linux scheduler picks the next runnable process — time slices, priorities, CFS virtual runtime, and why your busy server still feels responsive.

Details

Depth, delivered weekly

One technical dispatch a week — articles and episode notes before they go public.

One technical dispatch per week. No noise.