Compiler Engineer

Learn Rust: a systems language with the safety of a high-level one. Ownership, borrowing, pattern matching, zero-cost abstractions. Every lesson is hands-on with real cargo execution.

Level up from Rust Fundamentals. Ownership in depth, traits and trait objects, generics, lifetimes, iterator chains, Result/Option chaining, closures. The features that make Rust feel like Rust.

Beyond Rust Intermediate. Smart pointers (Box, Rc, RefCell), interior mutability, trait objects, declarative macros, unsafe basics. The features that close the gap between Rust and C++.

Learn Haskell: a pure, lazy, statically-typed functional language. Algebraic types, type classes, monads. Will rewire how you think about programs. Every lesson is hands-on with real GHC execution.

Level up from Haskell Fundamentals. Type classes, IO and the Monad pattern, Maybe/Either chains, do-notation. The features that make Haskell expressive — and how to write IO without breaking purity.

Beyond Haskell Intermediate. Applicatives, State and Reader monads, GADTs intro, lenses basics, type families. The features you actually use in production Haskell.

Learn OCaml: the rigorous functional language behind F#, Reason, and Jane Street's trading systems. Has the strictest type system you'll meet outside Haskell, with type inference so good you barely write a type. The language that taught me what 'expressive' really means.

Level up from OCaml Fundamentals. Modules, records, mutable references, option/result combinators, the standard library. The features that scale OCaml from a teaching language to industrial use.

Beyond OCaml Intermediate. Functors, GADTs, polymorphic variants, lazy evaluation, the Pervasives module. The features behind Jane Street's libraries and the Coq proof assistant.

Build a fully RFC 8259-compliant JSON parser from scratch. You'll tokenize structural characters, decode escape sequences and Unicode, parse numbers with strict grammar, and recursively assemble objects and arrays. By the end you'll deeply understand how json.loads, JSON.parse, and every other parser actually works.

Build a regex engine from first principles — literal matching, character classes, quantifiers, anchors, alternation, capture groups. You'll implement Thompson's NFA construction (1968!) and the parallel simulation algorithm that guarantees linear time. By the end you'll understand what makes RE2, Go's regexp, and Rust's regex crate fast and safe.

Build a Scheme/Lisp interpreter in ~200 lines: tokenize, parse to nested lists, evaluate atoms and expressions, support define and if, lambda + closures, recursion, list operations, and macros. The textbook (SICP) classic — every CS curriculum has this.

Build a Wadler-style pretty printer like prettier/black/gofmt: parse to AST/CST, define a Doc algebra (text/line/group/nest), make line-break decisions based on width, preserve comments through formatting, support hanging indent + alignment. The toolchain backbone of every modern codebase.

Build an ESLint/Pylint-style static analyzer: tokenize source, build an AST, walk it with visitor pattern, check naming/complexity/unused names/dead code, parse suppressions, load config from pyproject.toml, emit human/JSON/GitHub formats. The toolchain backbone of every modern codebase.

Build a C compiler from scratch: lexer, recursive-descent parser, type checker, IR generation, x86-64 code generation, optimization passes (constant folding, dead code, register allocation), and linking. Builds the full pipeline like chibicc, GCC, and Clang.