Foundations that stick.

Structured lessons, readable Go solutions, and a test runner that mirrors real interview platforms.

Learning Tracks

Compiler Foundations: Language, Tokens, Grammar
1 quiz
Start
Lexing: From Text to Tokens
1 problem
compilers lexing tokens
Start
Parsing & ASTs: Structure Over Text
1 problem, 1 quiz
compilers parsing ast
Start
Lowering: AST to Stack Bytecode
1 problem
compilers lowering bytecode
Start
Language Expansion: Variables, Statements, Functions
1 problem, 1 quiz
compilers lexing strings tokens
Start
Parsing Programs: Declarations and Statements
1 problem
compilers parsing ast statements
Start
Semantic Analysis: Names, Scopes, and Rules
1 problem, 1 quiz
compilers semantics scopes
Start
Bytecode & VM: Making It Run
2 problems
compilers bytecode lowering virtual machine
Start
Bytecode Format: A Real Compile Artifact
1 problem
compilers bytecode serialization
Start
Capstone: Source to Bytecode to VM
1 problem
compilers bytecode vm capstone
Start
v3 Language: Collections and Closures
1 problem
compilers lexing tokens collections
Start
v3 Parsing: Postfix, Maps, and Arrays
1 problem
compilers parsing ast collections +1
Start
v3 Semantics: Nested Functions
1 problem
compilers semantics scopes closures
Start
v3 Bytecode: Closures and Indexing
1 problem
compilers bytecode lowering closures
Start
v3 VM: Closures and GC
1 problem
compilers virtual machine bytecode gc
Start
v3 Bytecode Format (BC2)
1 problem
compilers bytecode serialization
Start
v3 Capstone: Full Pipeline
1 problem
compilers bytecode vm capstone
Start
v4 Control Flow: for, break/continue, && / ||
1 problem
compilers lexing tokens control flow
Start
v4 Parsing: for loops and short-circuit logic
1 problem
compilers parsing ast control flow
Start
v4 Semantics: loop rules and scope
1 problem
compilers semantics scopes loops
Start
v4 Bytecode: lowering control flow
1 problem
compilers bytecode lowering control flow
Start
v4 Capstone: Full Pipeline
1 problem
compilers bytecode vm capstone
Start
v5 Modules: imports, exports, and a linker mindset
1 problem
compilers lexing modules
Start
v5 Parsing: modules, imports, and member access
1 problem
compilers parsing modules
Start
v5 Semantics: import/export resolution
1 problem
compilers semantics modules
Start
v5 Bytecode: compiling modules
1 problem
compilers bytecode modules
Start
v5 Linker: merging module bytecode
1 problem
compilers bytecode linking
Start
v5 Capstone: Full Pipeline
1 problem
compilers bytecode vm capstone
Start
v6 Types: static guarantees for a dynamic VM
1 problem
compilers lexing types
Start
v6 Parsing: type annotations and signatures
1 problem
compilers parsing types
Start
v6 Semantics: static types on a dynamic runtime
1 problem
compilers semantics types
Start
v6 Capstone: Full Pipeline
1 problem
compilers bytecode vm capstone +1
Start

Fast Hints: Performance Checklist
1 problem, 1 quiz
hash-map arrays indexing
Start

Foundations that stick.

Learning Tracks

Foundations & Encodings

Merkle Trees

Transactions & UTXO

Script Validation

Proof of Work & Difficulty

Block Assembly

Chain Selection & Reorgs

Compiler Foundations: Language, Tokens, Grammar

Lexing: From Text to Tokens

Parsing & ASTs: Structure Over Text

Lowering: AST to Stack Bytecode

Language Expansion: Variables, Statements, Functions

Parsing Programs: Declarations and Statements

Semantic Analysis: Names, Scopes, and Rules

Bytecode & VM: Making It Run

Bytecode Format: A Real Compile Artifact

Capstone: Source to Bytecode to VM

v3 Language: Collections and Closures

v3 Parsing: Postfix, Maps, and Arrays

v3 Semantics: Nested Functions

v3 Bytecode: Closures and Indexing

v3 VM: Closures and GC

v3 Bytecode Format (BC2)

v3 Capstone: Full Pipeline

v4 Control Flow: for, break/continue, && / ||

v4 Parsing: for loops and short-circuit logic

v4 Semantics: loop rules and scope

v4 Bytecode: lowering control flow

v4 Capstone: Full Pipeline

v5 Modules: imports, exports, and a linker mindset

v5 Parsing: modules, imports, and member access

v5 Semantics: import/export resolution

v5 Bytecode: compiling modules

v5 Linker: merging module bytecode

v5 Capstone: Full Pipeline

v6 Types: static guarantees for a dynamic VM

v6 Parsing: type annotations and signatures

v6 Semantics: static types on a dynamic runtime

v6 Capstone: Full Pipeline

Compression Foundations & Entropy

Bit I/O & Universal Codes

Huffman Coding

Dictionary Coding

Transform Coding

Arithmetic / Range Coding

Capstone: DEFLATE-Lite

Crypto Foundations & Threat Models

Hash Functions & Merkle Structures

Block Ciphers & Modes

KDFs & Password Hashing

Public-Key Math Essentials

DB Internals Foundations

Page Layout and Slotted Pages

Buffer Pool and Eviction

WAL Recovery

B+Tree Indexing

Transactions and Locking

Arrays & Strings II

Sorting, Selection & Divide-and-Conquer

Greedy Fundamentals & Intervals

Prefix Sums & Binary Search on Answer

Monotonic Stack & Queue Patterns

Math & Number Theory Essentials

Dynamic Programming Basics

Dynamic Programming Advanced

Strings & Automata

Suffix Structures & Rolling Hash

Graph Traversal on Grids

Graphs Advanced

Graphs Beyond Traversal

Geometry Basics

Probabilistic Data Structures

Binary Trees

Heaps & Priority Queues

Advanced Data Structures

Advanced Trees

Union-Find (Disjoint Set Union)

Linked Lists