How CPython, C++, and PyTorch work under the hood: bytecode, memory, linking, and concurrency.

Language & Framework Internals

Deep dive into C++ memory allocation — stack frame internals, heap allocator mechanics, fragmentation, performance benchmarks, custom allocators, RAII, and debugging with AddressSanitizer and Valgrind.

C++ Stack vs Heap Memory: A Complete Guide

Understand C++ pointers and references with step-by-step memory diagrams: addressing, dereferencing, aliasing, array arithmetic, and object lifetime.

Pointers & References in C++

Learn Resource Acquisition Is Initialization (RAII) - the cornerstone of C++ memory management. Understand automatic resource cleanup and exception safety.

Memory Management & RAII in C++

Master C++11 smart pointers through interactive examples. Learn unique_ptr, shared_ptr, and weak_ptr with reference counting visualizations.

Smart Pointers in Modern C++

Master C++ OOP concepts including inheritance, polymorphism, virtual functions, and modern object-oriented design principles with interactive examples.

Object-Oriented Programming in C++

C++ virtual tables (vtables) explained. Learn virtual dispatch, single/multiple inheritance, RTTI, and object memory layout visually.

Comprehensive guide to C++ virtual tables, inheritance mechanisms, and memory layout with interactive visualizations

C++ Virtual Tables & Inheritance

Master C++ templates and the Standard Template Library. Learn generic programming, template metaprogramming, and STL containers and algorithms.

Templates & STL in C++

Complete C++ thread safety guide — race conditions with step-through simulation, mutexes, atomics, condition variables, deadlock detection, memory ordering, and Thread Sanitizer walkthrough.

Thread Safety: Concurrent Programming Fundamentals

Understand the complete C++ compilation pipeline from source code to object files. Learn preprocessing, parsing, code generation, and optimization stages.

C++ Compilation Overview

C++ preprocessor visualized: macros, header guards, conditional compilation, and #include directives explained interactively.

C++ Preprocessor Directives

Follow a C++ function from tokens to a simplified AST, then inspect exact source ranges, declaration references and types in a keyboard-accessible explorer.

C++ AST & Parsing Explained

C++ compiler optimization lab notebook — compare optimization levels, inspect compiler rewrites, diagnose auto-vectorization, and build production verification commands.

C++ Compiler Optimization

How C++ object files are linked into executables. Learn symbol resolution, static vs dynamic linking, and linker optimization.

C++ Linking Overview

Complete guide to C++ symbol resolution — how linkers match references to definitions, name mangling, strong vs weak symbols, ODR, template instantiation, linking order, and debugging undefined reference errors.

C++ Symbol Resolution: How the Linker Connects Your Code

How Linux loads C++ programs: captured ELF segments, runtime mappings, startup handoffs, lazy binding and practical loader debugging.

C++ Program Loading: From ELF to Running Process

Follow Linux shared libraries from dependency lookup to PLT/GOT binding, then build a versioned library, load a plugin and debug runtime linking failures.

C++ Dynamic Linking at Runtime

Explore CPython bytecode compilation from source to .pyc files. Learn the dis module, PVM stack operations, and Python 3.11+ adaptive specialization.

Python Bytecode Compilation

Learn how CPython implements PyObject, type objects, and the unified object model. Explore reference counting, memory layout, and Python internals.

Python Object Model Internals

A practical mental model for CPython memory management: names and references, object headers, PyMalloc arenas, reference counting, reuse paths, and memory profiling.

Python Memory Management

Understand CPython garbage collection: reference counting, generational GC for circular references, weak references, and gc module tuning strategies.

Python Garbage Collection

Learn when Python __slots__ reduces memory, how slot storage differs from __dict__, and the caveats for dataclasses and inheritance.

Python __slots__ Optimization

Follow CPython thread states, execution frames and shared objects through a GIL handoff. Inspect the source behind waiting, release, native work and application locks.

Python Global Interpreter Lock (GIL)

Complete guide to Python concurrency — OS threads, green threads (asyncio), the GIL, event loop internals, Python 3.13 free-threading, and production patterns.

Python Green Threads vs OS Threads

Deep dive into Python's asyncio library, understanding event loops, coroutines, tasks, and async/await patterns with interactive visualizations.

Python asyncio Event Loop

Master Python multiprocessing.shared_memory for zero-copy IPC. Learn synchronization, NumPy integration, and race condition prevention patterns.

Python Shared Memory

Follow PyTorch batches through worker queues, collation, ordered delivery and GPU transfer, then measure loading throughput and budget process memory.

PyTorch DataLoader Pipeline

Why DataLoader num_workers matters: processes hide load latency behind GPU work, how to find the sweet spot, and the memory/GIL pitfalls that come with the pool.

Understanding num_workers

How page-locked memory changes CPU-to-GPU transfers, the extra staging in pageable paths, and the conditions needed to overlap copies with GPU work.

Pinned Memory and DMA Transfers in PyTorch

Compare PyTorch DataParallel vs DistributedDataParallel for multi-GPU training. Learn GIL limitations, NCCL AllReduce, and DDP best practices.

DataParallel vs DistributedDataParallel

See how tail calls reuse stack frames, when compilers can eliminate them, and how CPython 3.14 applies tail calls to C opcode dispatch.

Tail Call Optimization and Python’s Tail-Call Interpreter

Follow direct-style and CPS factorial through the same calculation. See how closures carry pending work, why Python still grows call depth, and where trampolines fit.

Continuation-Passing Style: Make the Remaining Work Explicit

Step through mutual recursion and a Call/Done trampoline to see deferred work, bounded worker depth, base cases, and the allocation tradeoff.

Trampolines: Recursive Control Flow Through a Loop

Trace a small virtual machine through branches and loops, then compare switch, computed goto, and tail-call dispatch without changing its bytecode semantics.

Language & Framework Internals

C++ memory and objects

1. Storage, lifetime and ownership

Stack versus heap

2. Objects, dispatch and containers

3. Share state safely

Stack versus heap