Python Bytecode Compilation
Explore CPython bytecode compilation from source to .pyc files. Learn the dis module, PVM stack operations, and Python 3.11+ adaptive specialization.
Related
8 min read · beginner
Language & Framework Internals
How CPython, C++, and PyTorch work under the hood: bytecode, memory, linking, and concurrency.
- INT
- 31 concepts
All Language & Framework Internals Concepts
PyTorch DataLoader Pipeline
PyTorch DataLoader deep dive — Dataset, Sampler, Workers, Collate internals, num_workers throughput profiling, memory analysis, serialization costs, production patterns (LMDB, WebDataset), and bottleneck diagnosis.
Related
22 min read · intermediate
C++ Stack vs Heap Memory: A Complete Guide
Deep dive into C++ memory allocation — stack frame internals, heap allocator mechanics, fragmentation, performance benchmarks, custom allocators, RAII, and debugging with AddressSanitizer and Valgrind.
Related
18 min read · intermediate
Python Memory Management
A practical mental model for CPython memory management: names and references, object headers, PyMalloc arenas, reference counting, reuse paths, and memory profiling.
Related
14 min read · intermediate
Python Global Interpreter Lock (GIL)
Learn the CPython Global Interpreter Lock (GIL) from first principles: why it exists, how threads take turns, why I/O still works well, and when to use multiprocessing, asyncio, or native extensions.
Related
15 min read · intermediate
Pinned Memory and DMA Transfers in PyTorch
Why pin_memory=True matters: pageable paths pay two host copies and block the CPU; pinned memory enables one DMA hop and real overlap with GPU compute.
Related
10 min read · intermediate
C++ Symbol Resolution: How the Linker Connects Your Code
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.
Related
20 min read · intermediate
C++ Program Loading: From ELF to Running Process
How C++ programs are loaded — ELF segments, the _start to main() chain, dynamic linking with PLT/GOT, ASLR, real readelf/strace/proc maps output, and startup debugging.
Related
20 min read · intermediate
Understanding num_workers
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.
Related
9 min read · intermediate
Python Object Model Internals
Learn how CPython implements PyObject, type objects, and the unified object model. Explore reference counting, memory layout, and Python internals.
Related
10 min read · intermediate
Python Garbage Collection
Understand CPython garbage collection: reference counting, generational GC for circular references, weak references, and gc module tuning strategies.
Related
8 min read · intermediate
Python Optimization Techniques
Learn a profiler-first Python optimization workflow: measure bottlenecks, choose the right lever, and verify performance changes.
Related
12 min read · intermediate
Python __slots__ Optimization
Learn when Python __slots__ reduces memory, how slot storage differs from __dict__, and the caveats for dataclasses and inheritance.
Related
11 min read · intermediate
Python Green Threads vs OS Threads
Complete guide to Python concurrency — OS threads, green threads (asyncio), the GIL, event loop internals, Python 3.13 free-threading, and production patterns.
Related
20 min read · intermediate
Python asyncio Event Loop
Deep dive into Python's asyncio library, understanding event loops, coroutines, tasks, and async/await patterns with interactive visualizations.
Related
12 min read · intermediate
Python Shared Memory
Master Python multiprocessing.shared_memory for zero-copy IPC. Learn synchronization, NumPy integration, and race condition prevention patterns.
Related
9 min read · intermediate
Thread Safety: Concurrent Programming Fundamentals
Complete C++ thread safety guide — race conditions with step-through simulation, mutexes, atomics, condition variables, deadlock detection, memory ordering, and Thread Sanitizer walkthrough.
Related
20 min read · intermediate
C++ AST & Parsing Explained
Explore how C++ code is parsed into an Abstract Syntax Tree (AST). Learn lexical analysis, tokenization, and syntax parsing for systems programming.
Related
7 min read
C++ Compilation Overview
Understand the complete C++ compilation pipeline from source code to object files. Learn preprocessing, parsing, code generation, and optimization stages.
Related
5 min read
C++ Dynamic Linking at Runtime
Deep dive into dynamic linking — GOT/PLT lazy resolution, shared library creation, SONAME versioning, RPATH/RUNPATH, dlopen plugin systems, LD_PRELOAD, and debugging with LD_DEBUG.
Related
20 min read · intermediate
C++ Linking Overview
How C++ object files are linked into executables. Learn symbol resolution, static vs dynamic linking, and linker optimization.
Related
5 min read
Memory Management & RAII in C++
Learn Resource Acquisition Is Initialization (RAII) - the cornerstone of C++ memory management. Understand automatic resource cleanup and exception safety.
Related
3 min read
Modern C++ Features (C++11 and Beyond)
Explore modern C++ features including auto, lambdas, ranges, and coroutines. Learn how C++11/14/17/20 transformed the language.
Related
4 min read
Object-Oriented Programming in C++
Master C++ OOP concepts including inheritance, polymorphism, virtual functions, and modern object-oriented design principles with interactive examples.
Related
6 min read
C++ Compiler Optimization
C++ compiler optimization lab notebook — compare optimization levels, inspect compiler rewrites, diagnose auto-vectorization, and build production verification commands.
Related
14 min read · intermediate
Pointers & References in C++
Master C++ pointers and references through interactive visualizations. Learn memory addressing, dereferencing, smart pointers, and avoid common pitfalls.
Related
2 min read
C++ Preprocessor Directives
C++ preprocessor visualized: macros, header guards, conditional compilation, and #include directives explained interactively.
Related
5 min read
Smart Pointers in Modern C++
Master C++11 smart pointers through interactive examples. Learn unique_ptr, shared_ptr, and weak_ptr with reference counting visualizations.
Related
3 min read
Templates & STL in C++
Master C++ templates and the Standard Template Library. Learn generic programming, template metaprogramming, and STL containers and algorithms.
Related
6 min read
DataParallel vs DistributedDataParallel
Compare PyTorch DataParallel vs DistributedDataParallel for multi-GPU training. Learn GIL limitations, NCCL AllReduce, and DDP best practices.
Related
6 min read
C++ Virtual Tables & Inheritance
C++ virtual tables (vtables) explained. Learn virtual dispatch, single/multiple inheritance, RTTI, and object memory layout visually.
Related
15 min read