The Curious Engineer

All blogs / OS / kernel

Confessions of a Code Addict

blog.codingconfessions.com

I write about how computers work underneath the abstractions: compilers, operating systems, memory, performance, and low-level programming. Click to read Confessions of a Code Addict, by Abhinav Upadhyay, a Substack publication with tens of thousands of subscribers.

OS / kernelPerformance / optimizationCPU / microarchitectureCompilersPython

’23’24’25’26
Posts
127 from 26 Apr 2023 to 2 Oct 2026
Posting
monthly (16 in the last year)
Kind
personal blog
Feed
https://blog.codingconfessions.com/feed

2026 13

  1. How and Why fork() Uses Copy-on-Write
  2. How Copy-on-Write Works with Memory-Mapped Files
  3. Demand Paging in Action: mmap, Page Faults, and RSS
  4. Demand Paging: What Happens When Linux Handles a Page Fault
  5. x86 Addressing Modes, Part 2: Indirect, Indexed, and Offset-based Modes
  6. How Big Is a Physical Address?
  7. What Does a Page Table Entry Actually Store?
  8. Page Tables from First Principles
  9. Understanding a Process’s Address Space Layout
  10. Why Git Has a Variable Named false_but_the_compiler_does_not_know_it
  11. How Large Is the Virtual Address Space?
  12. Why do we need virtual memory?
  13. Virtual Memory From First Principles

2025 32

  1. How PyTorch Generates Random Numbers in Parallel on the GPU
  2. x86 Addressing Modes, Part 1 — Immediate and Direct Access
  3. A Systems Engineer’s Guide to Benchmarking with RDTSC
  4. My Top 5 Favourite Features in Python 3.14
  5. Understanding Weak References in Python
  6. Compiling Python to Run Anywhere
  7. What Makes System Calls Expensive
  8. Leveraging CPU’s Micro-Op Cache for Faster Loops
  9. Big O vs Hardware: Better Complexity ≠ Better Performance
  10. x86 Assembly Exercise #1: Toy kill Program (Solution)
  11. Understanding Registers and Data Movement in x86-64 Assembly
  12. A Programmer’s Guide to x86-64 Assembly (Series Overview)
  13. Why This Python Performance Trick Doesn’t Matter Anymore
  14. Making System Calls in x86-64 Assembly
  15. One Law to Rule Them All: The Iron Law of Software Performance
  16. Debugging X86-64 Assembly with GDB
  17. Building (and Breaking) Your First X86 Assembly Program
  18. The System-Level Foundation of Assembly
  19. Binary Arithmetic and Bitwise Operations for Systems Programming
  20. Understanding Computer Organization from First Principles
  21. Hardware-Aware Coding: CPU Architecture Concepts Every Developer Should Know
  22. Python Performance: Why 'if not list' is 2x Faster Than Using len()
  23. Your Enrollment is Confirmed!
  24. [Course Launch] Hands-on Introduction to X86 Assembly
  25. My Top 15 OS Books: From Theory and Implementation to Systems Programming
  26. Recording: How Modern CPUs Execute Your Code: A Deep Dive into Performance
  27. Contact Me
  28. A Software Engineer's Guide to Reading Research Papers
  29. Launching Live Courses on Systems Programming
  30. Linux Context Switches: The Truth About TLB Flushes
  31. Live Session: How Modern CPUs Execute Your Code: A Deep Dive into Performance
  32. How Unix Spell Ran in 64kB RAM

2024 47

  1. Linux Context Switching Internals: Part 1 - Process State and Memory
  2. Reflections on 2024 and Exciting Plans for 2025
  3. Recording: Live Coding a Bytecode Compiler for Python
  4. Context Switching and Performance: What Every Developer Should Know
  5. Live Session: Live Coding a Bytecode Interpreter for Python
  6. How Linux Implements the fork System Call
  7. An Unreachable Hidden XKCD Easter Egg inside CPython
  8. The Pythonic Emptiness
  9. Live Session: Live Coding a Bytecode Interpreter for Python
  10. The CAP Theorem of Clustering: Why Every Algorithm Must Sacrifice Something
  11. Speculative Decoding and Beyond: A Survey of Speculative Decoding Techniques
  12. CPython's Garbage Collector and its Impact on Application Performance
  13. Recording: Six Key Performance Engineering Lessons from 1BRC
  14. Celebrating 2^13 Subscribers & My Birthday
  15. The Design & Implementation of the CPython Virtual Machine
  16. CPython Internals: What Happens Before Bytecode Execution Starts
  17. (Live Session) Performance Thinking: Six Key Lessons from 1BRC
  18. Are Function Calls Still Slow in Python? An Analysis of Recent Optimizations in CPython
  19. How Simultaneous Multithreading Works Under the Hood
  20. Recording: How Hyper-Threading Works — A Microarchitectural Perspective
  21. Substack has Failed Indian Creators
  22. Looking Under the Hood of Python's Set Data Structure
  23. Live Session: How Hyper-Threading (Simultaneous Multithreading) Works — A Microarchitectural Perspective
  24. CPython Garbage Collection: The Internal Mechanics and Algorithms
  25. Invite your friends to read Confessions of a Code Addict
  26. Recording: CPython and ELF Essentials for Building a Basic Remote Profiler
  27. Everything You Wanted to Know About Profilers in Python
  28. How Python Compares Floats and Ints: When Equals Isn’t Really Equal
  29. CPython Memory Management Internals
  30. Live Session: CPython and ELF Essentials for Building a Basic Remote Profiler
  31. Live Session: CPython Memory Management Internals
  32. Recording of Live Session on CPython Virtual Machine Internals
  33. CPython Runtime Internals: Key Data Structures & Runtime Bootstrapping
  34. Live Session on CPython Virtual Machine Internals + Upcoming Posts
  35. Why Do Python Lists Multiply Oddly? Exploring the CPython Source Code
  36. Video: Architecture of Groq's LPU & Why is it so Fast?
  37. Recording: Comparing CPUs, GPUs & LPUs
  38. Recording: Comparing CPUs, GPUs & LPUs
  39. Live Session: CPUs, GPUs & LPUs + Ask Me Anything
  40. The Architecture of Groq's LPU
  41. Recording: Live Session on Performance Optimization Using 1BRC as a Case Study
  42. Recording: Live Session on Performance Optimization using 1BRC as a Case Study
  43. Performance Engineering and The Need for Speed
  44. Live Session on Performance Optimization Using 1BRC as a Case Study
  45. Recording: Performance Engineering Techniques Behind 1BRC
  46. Workshop on Performance Optimizations in Code: The One Billion Row Challenge
  47. New Year Slate at Confessions of a Code Addict

2023 33

  1. Celebrating 4096 Subscribers and Happy Holidays
  2. CPython Type System Internals: Video Series
  3. Design of the CPython Type System
  4. Emulating Inheritance and Polymorphism in C
  5. Decoding PyObject and PyTypeObject in CPython
  6. Implementation of the Float Built-in Type in CPython
  7. A War Story About a Python, a Fork, a Cow, and a Bug
  8. How Many Lines of C it Takes to Execute a + b in Python?
  9. CPython Object System Internals: Understanding the Role of PyObject
  10. Fast Computation of Fibonacci Numbers: Part II
  11. A Linear Algebra Trick for Computing Fibonacci Numbers Fast
  12. Code Confessions Digest #5: News, and Resources from Last Week
  13. What Every Developer Should Know About GPU Computing
  14. 1024 Reasons to Celebrate: Journey and Future of 'Confessions of a Code Addict'
  15. How Language Models Beat PNG and FLAC Compression & What It Means
  16. How CPython Implements and Uses Bloom Filters for String Processing
  17. Bloom Filters and Beyond: An Illustrated Introduction and Implementation
  18. Understanding Immortal Objects in Python 3.12: A Deep Dive into Python Internals
  19. How CPython Implements Reference Counting: Dissecting CPython Internals
  20. LZ77 Is All You Need? Why Gzip + KNN Works for Text Classification
  21. Decoding the ACL Paper: Gzip and KNN Rival BERT in Text Classification
  22. Code Confessions Digest #4: News, and Resources from Last Week
  23. Code Confessions Digest #3: News, and Resources from Last Week
  24. Common ChatGPT API Function Call Mistakes and How to Fix Them
  25. Weekly Code Confessions Digest #2: News, and Resources from Last Week
  26. A Tutorial Guide to Using The Function Call Feature of OpenAI's ChatGPT API
  27. Understanding DeepMind's AlphaDev Breakthrough in Optimizing Sorting Algorithms
  28. Weekly Code Confessions Digest: Exploring Intriguing Articles, Books, and Courses
  29. The Pursuit of Programming #2: Variables, Operators and Data Types
  30. Mojo: The Future of AI Programming 🔥
  31. The Pursuit of Programming #1: What, Why, and How to Start
  32. Will AI Replace Programmers? The Future of Coding in the Age of AI
  33. Confessions of a code addict

Undated 2

  1. Confessions of a Code Addict Podcast | Abhinav Upadhyay | Substack
  2. Paid plans