Virtual Machines Explained
A language VM is a computer built in software: bytecode as its instruction set, a garbage collector as its memory system, and a JIT as its "CPU." This video walks the life of a bytecode instruction from class file to native execution, and covers the services the VM provides that your program silently depends on — type checking at load time, exception handling, and synchronized locks.
Topics covered:
- Why bytecode exists: portability and one instruction set for many languages
- The class-loading pipeline: verification, linking, and initialization
- The execution engine: interpreting, then JIT-compiling hot code
- The VM's runtime services: GC, stack unwinding, and managed locking
- The stack-based vs. register-based instruction set difference
- Memory model: the heap, method area, and the native call stack
- How the JVM, CLR, and WebAssembly VMs compare
- The cost: startup, warmup, and getting faster as they run
Related articles
Boxing, Unboxing, and Value vs Reference Semantics
Why every boxed int is a heap allocation, why int[] beats ArrayList and Integer[] by 4-16x, how Java generics erasure forces boxing, and how C# structs avoid it.
Branch Prediction and CPU Pipelines: Why Sorted Data Is Faster
How the branch target buffer, speculative execution, and pipeline flushes make sorted arrays up to 10x faster, and why __builtin_expect, retpolines, and Spectre mitigations exist.
String Interning and Memory: Why Some == Comparisons Are Instant
How compilers and runtimes intern strings into symbol tables and pools, why identity comparison works on interned strings, and how Java, C#, and Python each behave.
More in Runtime & Execution
How Garbage Collection Actually Works
A visual walkthrough of mark-sweep, generational collection, and concurrent GC — the algorithms that keep your memory clean.
WatchWhat Your Code Does Before main()
The loader, the linker, the dynamic linker, and the runtime — everything that happens between pressing run and your first line of code.
WatchHow Threads Actually Work
The kernel scheduler, context switches, goroutines versus threads — a visual walkthrough of what 'running on a core' really means.
WatchAsync/Await Under the Hood
What async/await compiles to — state machines, continuations, and the executor — and how your async function actually runs on one or many threads.
DetailsInterpreters vs. Compilers
What an interpreter actually does at runtime versus what a compiler does before — ASTs, bytecode, and why the boundary keeps blurring.
DetailsReference Counting vs. Tracing GC
The two families of automatic memory management — refcounts, cycles, and ARC versus tracing collectors, roots, and reachability — compared on real trade-offs.
DetailsStack vs. Heap Memory
Where your variables actually live — the hardware stack's push and pop discipline versus the heap's malloc and free — and why the difference matters.
DetailsThe Event Loop, Visualized
How Node.js and the browser run one thread with many tasks — the call stack, the task queue, and microtasks — animated frame by frame.
DetailsJIT Compilers Explained
How just-in-time compilers work — profiling, tiered compilation, and generating machine code at runtime — from interpreter to native in microseconds.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.