Skip to content

Volume ITechnology

3.13.1 — Where Python Came From & How CPython Runs Your Code ​

You type python checkout.py and press Enter. A tenth of a second later your order total appears on the screen. Between those two moments, your text file was cut into pieces, turned into a tree, turned into a list of tiny instructions, and fed one instruction at a time into a loop written in C. This page walks that whole journey. Before that, it tells the story of why the language exists at all, because almost every odd thing about Python makes sense once you know who built it and what they were trying to fix.

1. The story: a holiday project that took over the world ​

A teaching language that almost made it ​

In the early 1980s, a research institute in Amsterdam called CWI built a language named ABC. ABC was designed for people who were not professional programmers. It used indentation instead of curly braces to show which lines belong together. It had very few rules, high-level lists and tables built in, and friendly error messages.

ABC failed. It could not easily talk to the operating system, it could not read files in flexible ways, and you could not extend it with new pieces. A young programmer at CWI named Guido van Rossum worked on ABC, and he watched those limits stop people again and again.

Christmas 1989 ​

By 1989 Guido was working on a different project at CWI, a distributed operating system called Amoeba. Writing system tools for Amoeba in C was slow and painful. Writing them as shell scripts was too limited. He wanted something in between: as friendly as ABC, but able to call into C and the operating system whenever needed.

So during the Christmas holidays of December 1989, he started writing a new interpreter as a hobby. He kept ABC's indentation and its clean look. He added what ABC was missing: modules, exceptions, and an easy way to plug in code written in C. He named it after the British comedy show Monty Python's Flying Circus, because he wanted the name to be short, a little unusual, and fun. That is why the Python documentation is full of spam and eggs rather than foo and bar.

He published version 0.9.0 on a Usenet group in February 1991. It already had classes, exceptions, functions, and the core types list, dict and str.

The years that shaped it ​

A few dates explain most of what you will meet in this chapter.

  1. 1994 — Python 1.0. It added lambda, map and filter, given by a user who missed them from Lisp.
  2. 2000 — Python 2.0. It added list comprehensions and a garbage collector that can clean up reference cycles. You will see that collector in 3.13.13.
  3. 2000 — the PEP process. A PEP, short for Python Enhancement Proposal, is a written design document. Every change to the language is argued in public through one. PEP 8 is the style guide. PEP 20 is "The Zen of Python", a list of nineteen sayings you can print by typing import this.
  4. 2008 — Python 3.0. This release fixed old mistakes on purpose and broke old code to do it. The biggest change: text became Unicode by default, and raw bytes became a separate type. Moving the world from Python 2 to Python 3 took twelve painful years. Python 2 was officially retired on 1 January 2020.
  5. 2018 — the BDFL steps down. Guido had the joke title Benevolent Dictator For Life, meaning he had the final word on every decision. After a bitter argument about the "walrus operator" := in PEP 572, he resigned the title. Since 2019 an elected Steering Council of five people decides instead.
  6. 2020 onward — the speed push. Guido joined Microsoft, which funded a team called Faster CPython. Python 3.11, released in 2022, ran typical code about 25% faster than 3.10. Python 3.13 and 3.14 added an optional build without the famous global lock (the GIL, explained in 3.13.13) and an experimental just-in-time compiler.

Since 2019, a new version of Python comes out every October. This page uses Python 3.14, released in October 2025, and every output shown here was produced by it.

The ideas that came from the story ​

You can now see where Python's personality comes from.

  • Readability first. ABC's lesson was that code is read far more often than it is written. Indentation is not decoration in Python. It is the grammar.
  • "Batteries included." ABC failed partly because it could not do real work. So Python ships with a huge standard library: files, JSON, dates, HTTP, compression, databases and much more.
  • Easy to connect to C. Guido needed to call C system code from day one. That is why Python became the glue for scientific libraries like NumPy, which do the heavy maths in C and let you steer them from Python.

2. "Python" and "CPython" are not the same thing ​

Python is the language: the rules about what valid code is and what it means. CPython is one program that runs Python code. It is written in C, it is the one you download from python.org, and it is what nearly everyone means by "Python".

Other programs also run Python code:

  • PyPy runs Python with a just-in-time compiler and is often several times faster for long-running pure-Python loops.
  • MicroPython runs a small subset of Python on tiny chips such as the ones in hobby electronics boards.
  • Jython and IronPython run Python on the Java and .NET platforms.

You can ask Python which one you are using.

python
import sys

print(sys.implementation.name)   # (1)
print(sys.version_info[:3])      # (2)
text
cpython
(3, 14, 6)
  • (1) sys.implementation.name names the program running your code. Here it is CPython.
  • (2) sys.version_info is the version as a tuple of numbers, so you can compare it in code, for example sys.version_info >= (3, 12).

Everything else on this page describes CPython, because that is what runs in production almost everywhere.

3. Is Python compiled or interpreted? Both. ​

People often say "Python is interpreted, so it is slow". That is half true. 3.2 explained the two classic strategies. A compiler turns your whole program into machine code before it runs. An interpreter reads your program and does what it says, step by step.

CPython does both, in two stages. First it compiles your source code into bytecode. Bytecode is a list of small, simple instructions for an imaginary computer. Then a loop written in C interprets that bytecode, one instruction at a time. That imaginary computer, together with the loop that runs it, is called a virtual machine.

Figure 1 shows the whole journey. We will walk each stage with real output.

① sourcecheckout.py② tokensNAME, OP, …③ ASTa tree of meaning④ bytecodecode object⑤ eval loopC code runs it.pyc file__pycache__/saved on import,reused next time②–④ happen once per file:this is the "compile" half
Figure 1 — How CPython runs a file. Stages ② to ④ compile the text into bytecode. Stage ⑤ interprets that bytecode. For imported modules, the bytecode is saved as a .pyc file so the next run can skip straight to stage ⑤.

Stage ②: the tokenizer cuts text into words ​

The first thing CPython does is break your text into tokens. A token is the smallest meaningful piece: a name, a number, an operator, a bracket. This is the lexer stage from 3.1. The standard library lets you watch it happen.

python
import io
import tokenize

source = "total = price * qty + shipping\n"
for tok in tokenize.generate_tokens(io.StringIO(source).readline):   # (1)
    print(tokenize.tok_name[tok.type], repr(tok.string))             # (2)
text
NAME 'total'
OP '='
NAME 'price'
OP '*'
NAME 'qty'
OP '+'
NAME 'shipping'
NEWLINE '\n'
ENDMARKER ''
  • (1) generate_tokens reads the source one line at a time and hands back each token it finds.
  • (2) Each token has a type, such as NAME or OP for operator, and the exact text it covered.

Notice what is missing: the spaces. The tokenizer throws them away because they carry no meaning between words. Indentation at the start of a line is different. In Python it does carry meaning, so the tokenizer turns it into special INDENT and DEDENT tokens, which act exactly like the { and } of JavaScript. That is how a language with no braces still has blocks.

Stage ③: the parser builds a tree ​

A flat list of tokens says nothing about which operation happens first. Does price * qty + shipping mean "price times (qty plus shipping)" or "(price times qty) plus shipping"? The parser answers that question by building an abstract syntax tree, or AST. An AST is a tree where each node is one operation and its children are the things it works on.

python
import ast

tree = ast.parse("total = price * qty + shipping")
print(ast.dump(tree, indent=2))
text
Module(
  body=[
    Assign(
      targets=[
        Name(id='total', ctx=Store())],
      value=BinOp(
        left=BinOp(
          left=Name(id='price', ctx=Load()),
          op=Mult(),
          right=Name(id='qty', ctx=Load())),
        op=Add(),
        right=Name(id='shipping', ctx=Load())))])

Read the tree from the bottom up. The innermost BinOp, short for binary operation, multiplies price by qty. Its result becomes the left side of the outer BinOp, which adds shipping. So multiplication happens first, exactly as in school maths. The parser decided that from the grammar's precedence rules, the same way 3.1 described.

Two small details are worth knowing. ctx=Load() means "read this name", and ctx=Store() means "assign to this name". And since Python 3.9, CPython's parser is a PEG parser, short for parsing expression grammar. The old parser could only look one token ahead, and that limit blocked some syntax the core team wanted. The match statement of 3.13.16 was only possible after the switch.

Tools you use every day read this same tree. Linters such as Ruff, formatters such as Black, and type checkers such as mypy all parse your code into an AST and then walk it.

Stage ④: the compiler produces bytecode ​

The compiler walks the AST and writes out bytecode. The dis module, short for disassembler, shows you the result in readable form. Here is a real function from a checkout service.

python
import dis

def order_total(price, qty, shipping):
    return price * qty + shipping

dis.dis(order_total)
text
  3           RESUME                   0

  4           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (price, qty)
              BINARY_OP                5 (*)
              LOAD_FAST_BORROW         2 (shipping)
              BINARY_OP                0 (+)
              RETURN_VALUE

The numbers on the left are source line numbers. Each line to their right is one bytecode instruction. Here is what each one does.

  1. RESUME marks the start of the function body. The interpreter uses it as a safe point to check for things like a pending signal, such as you pressing Ctrl+C.
  2. LOAD_FAST_BORROW_LOAD_FAST_BORROW pushes two local variables, price and qty, onto a value stack. A value stack is a pile of values where you can only add to the top and take from the top. "Fast" means the variable is a local, stored in a numbered slot rather than looked up by name. "Borrow" is a 3.14 speed trick that skips some bookkeeping. Two loads were fused into one instruction because that pair is so common.
  3. BINARY_OP 5 (*) pops the top two values, multiplies them, and pushes the result.
  4. LOAD_FAST_BORROW 2 (shipping) pushes shipping.
  5. BINARY_OP 0 (+) pops two values, adds them, and pushes the sum.
  6. RETURN_VALUE pops the top value and hands it back to the caller.

Compare this to the tree. The bytecode is the tree flattened into the order you would evaluate it by hand: fetch the two inputs, multiply, fetch the third, add. That is all a stack machine is.

The bytecode does not float around loose. It lives inside a code object, which also holds the names of the local variables, the constants the code uses, and the line-number table. Every function you write has one, reachable as __code__.

python
def order_total(price, qty, shipping):
    return price * qty + shipping

code = order_total.__code__
print(code.co_varnames)    # (1)
print(code.co_code[:12])   # (2)
text
('price', 'qty', 'shipping')
b'\x80\x00W\x01,\x05\x00\x00\x00\x00\x00\x00'
  • (1) co_varnames lists the local variable names. The bytecode refers to them by position: slot 0, slot 1, slot 2. That is why the dis output showed 1 (price, qty) and 2 (shipping).
  • (2) co_code is the raw bytecode, just bytes. dis exists so you never have to read this by hand.

The compiler also does small optimisations. Write SECONDS_PER_DAY = 60 * 60 * 24 and the bytecode simply contains the number 86400. The multiplication happened once, at compile time, a step called constant folding. You pay nothing for writing the readable version.

Stage ⑤: the evaluation loop runs it ​

The final stage is the heart of CPython: a giant loop in C, in a file historically called ceval.c. In spirit, it does this, forever:

  1. Read the next instruction.
  2. Jump to the C code for that instruction.
  3. Run it, which usually pushes and pops values on the stack.
  4. Go back to step 1.

The best way to understand that loop is to build a tiny one yourself. This toy runs the six instructions we just saw.

python
def run(instructions, local_vars):
    stack = []                                   # (1)
    for op, arg in instructions:                 # (2)
        if op == "LOAD_FAST":
            stack.append(local_vars[arg])        # (3)
        elif op == "BINARY_OP":
            right = stack.pop()                  # (4)
            left = stack.pop()
            stack.append(left * right if arg == "*" else left + right)
        elif op == "RETURN_VALUE":
            return stack.pop()                   # (5)

program = [
    ("LOAD_FAST", "price"), ("LOAD_FAST", "qty"), ("BINARY_OP", "*"),
    ("LOAD_FAST", "shipping"), ("BINARY_OP", "+"), ("RETURN_VALUE", None),
]
print(run(program, {"price": 250, "qty": 3, "shipping": 40}))
text
790
  • (1) The value stack starts empty.
  • (2) The loop reads one instruction at a time, an operation name and its argument.
  • (3) A load pushes a variable's value onto the stack.
  • (4) A binary operation pops the right operand first, because it was pushed last, then the left one. It pushes the result.
  • (5) A return pops the final answer.

Real CPython has more than two hundred instructions, a separate stack frame for every function call, and decades of tuning. But the shape is exactly this. When people say "Python is slow", this loop is what they mean. Every + costs a trip around the loop, a look at the types of both values, and a call to the right C function. A compiled language like C does the same addition in one machine instruction.

4. The .pyc file and __pycache__ ​

Compiling takes time. A big application imports hundreds of modules, and parsing all of them on every start would be slow. So when CPython imports a module, it saves the compiled bytecode to disk in a folder named __pycache__, as a .pyc file. The next time, it loads the saved bytecode and skips stages ② to ④.

Let us watch it happen with two files in a small shop project.

python
# shop/pricing.py
SECONDS_PER_DAY = 60 * 60 * 24
print("pricing loaded, __name__ =", __name__)

def add_tax(amount):
    return amount * 1.18
python
# shop/checkout.py
import pricing                 # (1)
print(pricing.add_tax(200))

Run python checkout.py inside the shop folder, and then list the folder.

text
pricing loaded, __name__ = pricing
236.0

shop/
  checkout.py
  pricing.py
  __pycache__/
    pricing.cpython-314.pyc     ← (2)
  • (1) Importing pricing compiles it and writes the cache file.
  • (2) The file name records the Python version, cpython-314. Different Python versions produce different bytecode, so each one keeps its own file and they never clash.

Notice that there is no checkout.cpython-314.pyc. The file you run directly is compiled fresh every time and never cached. Only imported modules are cached. This is one reason large projects keep their main script tiny and put the real code in modules.

How does CPython know the cache is still valid? The .pyc file starts with a 16-byte header. The first four bytes are a magic number that identifies the bytecode version. The header also records the source file's last-modified time and size. If you edit pricing.py, the time no longer matches, so CPython recompiles and rewrites the cache. You never need to delete __pycache__ by hand, and it is safe to delete whenever you like. Projects list it in .gitignore because it is a cache, not source code.

5. if __name__ == "__main__": explained once and for all ​

Look again at the output above: __name__ = pricing. Every module gets a variable called __name__. When the module is imported, __name__ is set to the module's name. When the file is run directly, __name__ is set to the special string "__main__".

That gives you a way to write code that runs only when the file is the program, and not when someone imports it.

python
# shop/pricing.py
def add_tax(amount):
    return amount * 1.18

if __name__ == "__main__":                        # (1)
    print("running pricing directly:", add_tax(100))
text
$ python pricing.py
running pricing directly: 118.0

$ python checkout.py
236.0
  • (1) When you run pricing.py directly, the condition is true and the demo line runs. When checkout.py imports it, __name__ is "pricing", so the demo line is skipped.

Why does Python need this trick at all? Because in Python, importing a module runs it. There is no separate "declarations" phase. def and class are ordinary statements that execute from top to bottom and create objects as they go. Any loose code at the top level of a module runs on import. The __main__ guard is how you keep script-only code from running when the module is used as a library. 3.13.11 explains the import system fully.

6. Why Python got faster: the specializing interpreter ​

3.6.9 showed how V8 makes JavaScript fast. It watches which types actually show up, guesses that they will keep showing up, and generates fast code for that guess. If the guess turns out wrong, it throws the fast code away. CPython 3.11 brought a gentler version of the same idea into the interpreter itself, described in PEP 659. It is called the specializing adaptive interpreter.

The idea is simple. A plain BINARY_OP has to check the types of its operands every single time. But in a real program, the same line almost always sees the same types. So after an instruction has run a few times, CPython rewrites it in place with a specialised version that assumes those types. If the assumption ever fails, it falls back to the general version and may specialise again later.

You can watch this with dis(..., adaptive=True).

python
import dis

def order_total(price, qty, shipping):
    return price * qty + shipping

for _ in range(1000):
    order_total(250, 3, 40)               # (1)
dis.dis(order_total, adaptive=True)

for _ in range(1000):
    order_total(249.99, 3.0, 40.0)        # (2)
dis.dis(order_total, adaptive=True)
text
  3           RESUME_CHECK             0

  4           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (price, qty)
              BINARY_OP_MULTIPLY_INT   5 (*)
              LOAD_FAST_BORROW         2 (shipping)
              BINARY_OP_ADD_INT        0 (+)
              RETURN_VALUE
  3           RESUME_CHECK             0

  4           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (price, qty)
              BINARY_OP_MULTIPLY_FLOAT 5 (*)
              LOAD_FAST_BORROW         2 (shipping)
              BINARY_OP_ADD_FLOAT      0 (+)
              RETURN_VALUE
  • (1) After a thousand calls with whole numbers, BINARY_OP has become BINARY_OP_MULTIPLY_INT and BINARY_OP_ADD_INT. These versions do a quick "are both of these ints?" check and then go straight to integer maths.
  • (2) Now we call it with floats. The int check fails, the instruction falls back, and after enough float calls it re-specialises to BINARY_OP_MULTIPLY_FLOAT. The bytecode adapts to what your program actually does.

This is why keeping types consistent makes Python faster, just as it does in JavaScript. A function that always gets integers stays specialised. A function that gets an int one call, a float the next and a string the next keeps falling back to the slow, general path.

The experimental JIT ​

Python 3.13 added an experimental JIT compiler, short for just-in-time, described in PEP 744. A JIT turns hot bytecode into real machine code while the program runs. CPython's JIT uses a technique called copy-and-patch. Machine-code templates for each instruction are prepared when CPython itself is built. At run time, the JIT copies the right templates one after another and patches in the actual addresses and values. It is much simpler than V8's optimising compiler, and today the speed-ups are modest.

In 3.14, the official Windows and macOS builds include the JIT, but it is switched off. You can check, and turn it on with the environment variable PYTHON_JIT=1.

python
import sys

print(sys._jit.is_available())   # (1)
print(sys._jit.is_enabled())     # (2)
text
True
False
  • (1) This build of CPython contains the JIT.
  • (2) It is not running, because it is still off by default. The leading underscore in sys._jit warns you that this is an internal, experimental interface.

7. Where the speed really comes from ​

Here is the honest picture you can give in any design discussion.

Pure Python loops are slow compared with C, Go or Java. Often they are ten to a hundred times slower, because of the evaluation loop's per-instruction work and because every value is a full object in memory (3.13.2 shows why).

Real Python programs are often fast anyway, for three reasons.

  1. The heavy work happens in C. sorted(), dict lookups, str.join, NumPy maths and database drivers all run as compiled C. Your Python code only steers them. A senior engineer writes code that hands big chunks of work to these built-ins instead of looping in Python.
  2. Most servers wait, they do not compute. A typical web request spends most of its time waiting for a database or another service. While it waits, the speed of the evaluation loop does not matter. 3.13.15 and Chapter 3.14 show how Python serves thousands of waiting requests at once.
  3. The interpreter keeps improving. 3.11 specialisation, 3.13 and 3.14 JIT work, and the free-threaded build all chip away at the gap.

What the interviewer will push on ​

"Is Python compiled or interpreted?" They are checking whether you know there are two stages. A memorised answer says "interpreted". A good answer says CPython compiles source to bytecode, caches it as .pyc for imported modules, and then interprets that bytecode in a C evaluation loop. The common wrong answer is that .pyc files are machine code. They are not. They are bytecode for CPython's virtual machine, and they only work with the same Python version.

"When is a .pyc file created, and when is it used?" They want to hear that it is written on import, not for the script you run directly. It is reused when the magic number matches and the source file's timestamp and size are unchanged. The tell of real understanding is knowing why the file name includes cpython-314: bytecode changes between versions, so each version keeps its own cache.

"What does if __name__ == '__main__' do, and why does Python need it?" The memorised answer says "it runs the main function". The good answer explains that importing a module executes its top-level code, so the guard separates "run as a program" from "used as a library". Bonus: python -m package.module also sets __name__ to "__main__".

"Why is Python slower than Java or Go, and what has the core team done about it?" They are checking for the mechanism, not the slogan. Name the per-instruction overhead of the evaluation loop, dynamic type checks on every operation, and every value being a heap object. Then name the fixes: the 3.11 specializing adaptive interpreter, the experimental copy-and-patch JIT, and the free-threaded build. The common wrong answer is "because of the GIL". The GIL limits running Python threads in parallel. It does not make a single thread slow.

"What is the difference between Python and CPython?" Python is the language. CPython is the reference implementation written in C. PyPy, MicroPython and GraalPy are other implementations. The tell is knowing that some behaviours you rely on, such as reference counting freeing objects immediately, are CPython details and not promises of the language.

Something to volunteer that nobody asks for: CPython rewrites its own bytecode while your program runs. Run a function with ints, then disassemble it with adaptive=True, and BINARY_OP has become BINARY_OP_ADD_INT. That shows you understand why consistent types make Python faster, not just that "3.11 is faster".

Recall

  • Python grew from ABC, a teaching language at CWI in Amsterdam. Guido van Rossum started Python at Christmas 1989, released it in 1991, and named it after Monty Python. Python 3 (2008) made text Unicode and broke old code. Since 2019 an elected Steering Council runs the language, and changes are argued in PEPs.
  • Python is the language. CPython is the C program that runs it, and the one nearly everyone uses.
  • CPython compiles and then interprets: source → tokens → abstract syntax tree → bytecode inside a code object → the C evaluation loop running a value stack. dis shows the bytecode. ast shows the tree.
  • Imported modules are cached as .pyc files in __pycache__, tagged with the Python version and checked against the source file's time and size. The script you run directly is never cached.
  • __name__ is "__main__" when a file is run directly, and the module name when it is imported. Importing a module runs it.
  • Since 3.11, the specializing adaptive interpreter rewrites hot instructions for the types it actually sees, such as BINARY_OP_ADD_INT. Consistent types stay fast. 3.13 added an experimental copy-and-patch JIT, off by default.

Self-test: Name the five stages of running a file. Why is there no .pyc for the script you run directly? What does BINARY_OP_ADD_INT tell you about how CPython got faster? Why does a Python module need the __main__ guard when a Java class does not?

Quiz Bank ​

FoundationalWhat is bytecode, and why does CPython use it instead of reading source text directly each time?

Bytecode is a list of small, simple instructions for CPython's virtual machine, such as "push this local variable" or "add the top two values". Reading source text is slow. The text has to be tokenized, parsed into a tree, and checked every time. Bytecode is already in a form the evaluation loop can run directly, so each line only has to be compiled once. For imported modules, the bytecode is even saved to disk as a .pyc file, so later runs skip compilation entirely.

AppliedYou delete the __pycache__ folder in production. What happens?

Nothing breaks. On the next start, every imported module is recompiled from source and its .pyc file is rewritten, so startup is slightly slower once. If the folder cannot be written, for example in a read-only container, CPython simply compiles in memory every time and carries on. Some teams pre-compile with python -m compileall when they build a container image, so the cache already exists and startup stays fast.

InterviewA function is called a million times, first with ints and later with floats and strings mixed. Why might it get slower, and how would you show it?

Since Python 3.11, CPython rewrites each hot instruction into a specialised version for the types it sees, such as BINARY_OP_ADD_INT. While every call uses ints, the fast version runs. When floats and strings start arriving, the type check in the specialised instruction fails, it falls back to the general BINARY_OP, and if the types keep changing it cannot stay specialised. You can show it with dis.dis(func, adaptive=True) after each phase, and you can measure it with the timeit module. The fix is to keep the types on a hot path consistent, for example by converting input to one type at the edge of the program.

StaffA team says we should rewrite our Python service in Go because Python is slow. What questions do you ask first?

First ask where the time goes. Profile one slow request. If most of the time is spent waiting on the database or other services, a faster language will not help much, and better queries, caching or concurrency will. If the time really is CPU-bound Python, ask whether the hot loop can be handed to C-backed tools such as built-ins, NumPy or a compiled extension. Then ask whether the team can run more processes, since Python scales out across processes well. Only if a large amount of pure-Python CPU work remains, and it costs real money or latency, does a rewrite of that one hot component make sense. Rewriting everything trades a known performance problem for an unknown correctness problem.

Next: every value in that evaluation loop is an object. 3.13.2 shows what an object really is, why a variable is only a label stuck on one, and why that single idea explains most Python bugs.

Combine chapters into one PDF

Pick the chapters you want. They print in the order you pick them.

Volume I — Technology
Part 0 — Retention & Notation
Part 1 — Foundations of Computation
Part 2 — Operating Systems
2.1 The Kernel
2.2 Processes
2.3 Threads & Scheduling
2.4 Concurrency Under the Hood
2.5 Memory Management
2.6 File Systems
2.7 Input/Output
2.8 Linux for Engineers
2.9 Windows & macOS in Practice
Part 3 — Languages, Compilers & Runtimes
3.6 JavaScript & V8
3.7 TypeScript
3.8 Node.js Internals
3.13 Python & CPython
3.14 FastAPI & Production Python
Part 4 — Data Structures & Algorithms
4.0 Classic Problems — Before NeetCode
4.4 Arrays & Hashing — Problems
4.5 Two Pointers
4.6 Sliding Window
4.8 Stack — Problems
4.9 Linked List — Problems
4.11 Binary Search — Problems
4.13 Trees
4.14 Tree — Problems
4.15 Trie — Problems
4.17 Heap — Problems
4.18 Backtracking — Problems
4.19 Graphs
4.20 Graph — Problems
4.21 Advanced Graph — Problems
4.23 1-D DP — Problems
4.24 2-D DP — Problems
4.26 Greedy — Problems
4.27 Interval — Problems
4.28 Math & Geometry — Problems
4.30 Bit Manipulation — Problems
Part 5 — Networking & the Web
5.3 IP
5.4 Transport
5.6 HTTP
Part 6 — Frontend Engineering
6.1 Browser Internals
6.2 HTML & CSS Mastery
6.3 JavaScript in the Browser
6.4 React, from First Component to Full Shop
6.5 Frameworks & Rendering
6.8 UI Engineering & Patterns
Part 7 — Databases & Storage
7.2 SQL Mastery
7.3 Storage Engine Internals
7.4 Transactions
7.5 NoSQL Taxonomy
7.8 Analytics & Big Data
Part 8 — Security, Identity & Cryptography
8.2 Cryptography
8.3 Protocols of Trust
8.4 Identity: AuthN & AuthZ
8.5 Application Security
8.6 Infrastructure Security
Part 9 — Software Design (LLD)
9.2 OOP Foundations
9.3 Design Principles
9.4 Design Patterns
9.5 Concurrency
9.6 API Design
9.7 LLD Interview Machines
9.9 Node/Express Production Playbook
Part 10 — Distributed Systems & HLD
10.7 Consistency & Consensus
10.8 Messaging & Microservices
10.14 Caching
Building blocks from the design seat
Part 11 — System Design Case Studies
Part 12 — AI & ML Engineering
12.1 What AI Engineering Is
12.2 The Math You Need
12.3 Classical Machine Learning
12.4 Data for ML
12.5 Deep Learning
12.6 Embeddings & Vector Search
12.7 Transformers & LLMs
12.8 Building with LLMs
12.9 Retrieval-Augmented Generation
12.10 Agents
12.11 Adapting Models
12.12 Production AI
12.13 Multimodal AI
12.14 AI Security & Governance
12.15 Case Studies & Capstone
Part 13 — Cloud, DevOps & Infrastructure
13.11 Git, from First Commit to Team Workflow
Part 14 — Containers: Docker & Kubernetes
14.1 Foundations
14.2 Docker
14.3 Kubernetes
14.4 Kubernetes on Azure
Part 15 — The Craft & Career
Nothing picked yet