Skip to content

FIRST-PRINCIPLES SOFTWARE ENGINEERING

Opening the Black Box of Software Engineering.

Skip surface-level tutorials. We visualize how runtimes, compilers, memory models, and distributed systems actually execute under the hood.

  • 100% Visual Architecture
  • Zero Talking-Head Fluff
  • Open-Source Companion Repos
runtime_trace.sys
  1. 01fn main() {
  2. 02 let data = fetchPayload(sock)
  3. 03 log("read scheduled")
  4. 04}
  5. 05
  6. 06fn fetchPayload(sock) {
  7. 07 let buf = allocBuffer(4096)
  8. 08 io.readAsync(sock, buf, onRead)
  9. 09 return buf
  10. 10}
  11. 11
  12. 12fn allocBuffer(size) {
  13. 13 return heap.alloc(size)
  14. 14}
  15. 15
  16. 16fn onRead(buf) {
  17. 17 parse(buf)
  18. 18}

Call Stack

  1. main()

Memory Heap

  • empty

Task / I/O Queue

  1. empty

Push main() Stack Frame

The runtime reserves a stack frame for main(), holding its return address and local variables, before the first instruction runs.

Methodology

How every episode works.

One mechanism per episode, traced on screen from start to finish, with code to run afterwards.

  • Zero Talking-Head Fluff

    100% screen-focused visual mental models, frame-by-frame execution traces, and architectural diagrams.

  • First-Principles Mechanics

    Opening the black box—tracing AST parsing, memory pointers, OS threads, event loops, and wire protocols rather than surface syntax.

  • Companion Code & Labs

    Every episode ships with runnable GitHub repositories, step-by-step mental model diagrams, and debugging challenges.

Curriculum

From how code runs to how systems scale.

Three language-agnostic tracks. Each one builds on the last.

Runtime & Engine Internals

How programs are parsed, compiled, laid out in memory, collected, and scheduled.

  1. Lexical & AST Parsing

    How source text becomes tokens, and tokens become a syntax tree.

  2. Bytecode & JIT Compilation

    How engines execute code, and when they compile it to machine code.

  3. Stack vs. Heap Memory Allocation

    Where values live, and why some outlive the function that created them.

  4. Garbage Collection Algorithms

    How runtimes find and reclaim memory that is no longer reachable.

  5. Concurrency & Event Loops

    How a single thread serves thousands of connections.

View the full syllabus

Flagship episodes

Start with these three.

All episodes on YouTube

Open source

Every episode ships with code you can run.

Clone the exercises, run the benchmarks on your own machine, and inspect the source of every diagram.

View GitHub Organization
github.com/insideruntimedev

$ tree -d insideruntimedev

$ git clone https://github.com/insideruntimedev/runtime-internals.git$ cd runtime-internals/01-execution-frames

Release notes

Get Episode Diagrams & Source Code in Your Inbox

One email when an episode is released, with its diagrams and code.

Unsubscribe at any time. Privacy policy. Questions? youtube@alphasquare.in

AN ALPHA SQUARE ENGINEERING INITIATIVE

Need First-Principles Engineering for Your Product?

InsideRuntime is built and maintained by Alpha Square—a software engineering consultancy architecting high-performance web platforms, mobile applications, and scalable backend systems.