Courses
Six self-directed weekend courses, run in parallel. Courses 1–4 follow the same weekly pattern: read concept → prove/exercise → implement → benchmark → write a staff-level note. Course 5 is the shared mathematical and theoretical backbone — pure theory notes drawn from the core textbooks under the other courses. Course 6 is a 10-week practical microelectronics and signal-processing course done on the bench with real instruments.
Weekend rhythm: Saturday = reading + theory exercises + implementation. Sunday = implementation + benchmark + staff-level note. Optional weeknight = 30–60 min cleanup or reading.
Note on AI use: The weekly lecture notes and syllabus summaries on this site are drafted with AI assistance, so each week has a consistent structure to study from. The substance is mine: every math proof and exercise solution is worked by hand on paper first and converted to LaTeX/KaTeX/MathJax using AI for typesetting only, and all code is written by me. The goal is to learn the material, which only happens by producing the proofs and the code myself.
Course 1 — Autonomy ML Systems + Embedded Robotics + Vision + Jetson
A 10-week course covering the ML systems, GPU compute, and embedded robotics foundations for AV and robotics engineering, assuming the math from Course 5 and the signal processing from Course 6. Three role families targeted: ML Frameworks & Efficiency Engineer, Prediction & Planning ML Engineer, and Embedded Software Engineer.
Phase 1 · Weeks 1–3 — GPU Compute and ML Numerical Foundations
CUDA and Metal first principles: threads, blocks, memory hierarchy, reductions, and the roofline. AV scene representation, ego-centric coordinate frames, and trajectory geometry (curvature, kinematics). Mixed precision (fp32/fp16/bf16/int8), numerical stability, and quantization for ML workloads.
Phase 2 · Weeks 4–7 — Prediction, Planning, and ML Efficiency
Probabilistic, multimodal trajectory prediction and its metrics. Loss functions, backprop, and a tiny learned predictor. Planning: metrics, physical feasibility, and graph search. ML efficiency: profiling plus a custom Triton/CUDA kernel and a CUDA-vs-Metal comparison.
Phase 3 · Weeks 8–10 — Embedded Robotics and Jetson Integration
Linux real-time control loops, jitter measurement, and a CAN actuator protocol with SocketCAN and fault injection. Sensor integration and state estimation with Bayes/Kalman filters. Capstone: safety state machine, watchdog, rate limiter, calibration tools, and full Jetson integration.
Course 2 — C++20 + Vulkan Graphics/Physics Engine for Self-Driving Car Simulation
A 10-week course building a real-time simulation engine from scratch in C++20 and Vulkan, assuming the transforms, mechanics, geometry, and optics from Course 5. The final product is a small, understandable portfolio engine that generates a synthetic driving world usable for testing self-driving vision, detection, and planning algorithms.
Phase 1 · Weeks 1–3 — Engine + Vulkan Foundations
C++20 engine skeleton, fixed-timestep simulation loop, and GLFW window. Vulkan bring-up: triangle render, swapchain, shaders, RenderDoc. Meshes, vertex/index/uniform buffers, descriptor sets, depth buffer, lighting, and materials.
Phase 2 · Weeks 4–6 — Road World, Traffic, Physics, and Collision
Road/lane geometry, lane graph, and procedural road mesh generation. Traffic lights, stop signs, crosswalks, a rule engine, and traffic agents with car-following behavior. Ego vehicle with the kinematic bicycle model and collision detection with broad/narrow-phase spatial acceleration.
Phase 3 · Weeks 7–10 — Sensors, Perception, Planning, and Polish
Camera sensor simulation: RGB, depth, and semantic ground-truth buffers via MRT. Classical + tiny-CNN perception baselines evaluated against ground truth. Route/local planning and a deterministic scenario/regression system. Capstone: performance engineering (instancing, culling, SoA, multithreading) and a polished, benchmarked demo.
Course 3 — NLP + Deep Learning + LLM
A 10-week course covering classical NLP, modern deep learning NLP, transformers, LLMs, masked language models, instruction tuning, alignment, retrieval-augmented generation, information extraction, and practical NLP/LLM system design — assuming the probability, optimization, and information theory from Course 5 and the DSP speech front-end from Course 6. Primary resources: Stanford CS224N, MIT 6.S191, and Jurafsky & Martin Speech and Language Processing. The portfolio artifact is a citation-grounded RAG assistant over course notes, papers, books, and technical documents.
Phase 1 · Weeks 1–3 — Foundations: Text, Tokens, Embeddings, Sequences
Tokenization, byte-pair encoding, and n-gram language models with perplexity. Dense word embeddings (skip-gram, geometry) and text classification as the warm-up application. RNNs and LSTMs for sequence modeling and the long-range bottleneck.
Phase 2 · Weeks 4–6 — Syntax, Attention, and Transformers
Sequence labeling and parsing: POS, NER, HMMs/Viterbi, and dependency parsing. Attention and seq2seq machine translation with the query/key/value abstraction. Transformer built from scratch: multi-head self-attention, positional encoding, residuals/layernorm, causal decoder-only LM.
Phase 3 · Weeks 7–10 — LLMs, Alignment, Retrieval, and Final Project
Large language models, scaling, prompting, and masked models (BERT, bi-/cross-encoders). Post-training: instruction tuning, RLHF, DPO, and LoRA. Retrieval and RAG (BM25 + dense + rerank), information extraction, and agents. Capstone: a citation-grounded, evaluated RAG assistant.
Course 4 — Low-Level CS: Bits, CPU, ARM Assembly, Linux Internals, and Performance
A 10-week weekends-only course building low-level CS intuition from first principles. Primary books: Plantz Introduction to Computer Organization: ARM Edition for bits, arithmetic, Boolean logic, CPU architecture, and ARM64 assembly; Bryant & O’Hallaron Computer Systems: A Programmer’s Perspective as the x86-64 companion; Fox Computer Architecture for digital logic and memory hierarchy; Ward How Linux Works for Linux boot, processes, memory, filesystems, networking, devices, and systemd. ARM64/AArch64 is the primary ISA, with the x86-64 equivalent covered alongside it and LLVM IR used as the architecture-neutral layer (one C source → one IR → both ISAs). This course overlaps least with the foundation courses, so the 10-week schedule comes mainly from merging adjacent weeks; IEEE 754 builds on Course 5 and the transistor-level basis of logic gates on Course 6. The capstone is syslens, a Linux observability tool in C/C++ using /proc, /sys, and direct syscalls.
Phase 1 · Weeks 1–4 — Bits, Logic, CPU, and ARM64 + x86-64 Assembly
Data representation and arithmetic: bits, hex, endianness, two’s complement, and IEEE 754. Boolean algebra, logic gates, and combinational circuits (half/full-adder). A tiny CPU emulator with fetch/decode/execute. Assembly basics on two ISAs: ARM64 (primary) and x86-64 (the CISC equivalent), with LLVM IR as the neutral bridge — registers, instructions, load/store vs register-memory.
Phase 2 · Weeks 5–6 — Control Flow, the Stack, ABI, and C/C++ Lowering
Control flow as compare-and-branch, stack frames, function calls, recursion, and the AArch64 calling convention (ABI). C/C++ memory layout: struct padding/alignment, pointer arithmetic, AoS vs SoA, virtual dispatch, and vtables.
Phase 3 · Weeks 7–10 — Linux Internals, Networking, Devices, and Performance
Processes, syscalls, signals, a mini-shell, and system startup (boot/systemd/journald). Virtual memory, mmap, caches, filesystems, and I/O. Networking (TCP/UDP sockets), devices, /dev//sys, interrupts, and GPIO. Capstone: performance engineering with perf and the syslens observability tool.
Course 5 — Mathematical & Theoretical Foundations
A 20-week theory course: the mathematical backbone under the other courses. It works through the highest-value sections of the core textbooks — linear algebra, numerical computing, real analysis and topology, probability, optimization, information theory, complex analysis, signals and transforms, algorithms and computation theory, classical mechanics, differential geometry, and electrodynamics/optics — ordered by dependency. These are pure study notes (definitions, key theorems, and intuition); the proofs are worked by hand.
Phase 1 · Weeks 1–5 — Linear Algebra, Numerical Computing, and Analysis Foundations
Linear maps, matrices, and eigenstructure. Inner products, orthogonality, the spectral theorem, the SVD, and determinants. Numerical linear algebra: norms, QR, least squares, conditioning, floating point, and LU. Eigenvalue algorithms and Krylov-subspace iterative methods. Real analysis and metric-space topology: sequences, continuity, uniform convergence, differentiation, and compactness.
Phase 2 · Weeks 6–10 — Probability, Optimization, and Information
Probability foundations, random variables, expectation, and covariance. Limit theorems, Markov chains, and Bayesian/classical inference. Convex sets and functions. Convex problems, Lagrangian duality, KKT conditions, and optimization algorithms. Information theory: entropy, KL divergence, mutual information, compression, and maximum entropy.
Phase 3 · Weeks 11–15 — Complex Analysis, Signals, Transforms, and Computation
Complex analysis: analytic functions, Cauchy–Riemann, power and Laurent series, poles and residues. Signals and systems, LTI/convolution, Fourier transforms, and sampling. Laplace and z-transforms, filter design, the DFT, and the FFT. Algorithm design paradigms: divide-and-conquer, graphs, greedy, dynamic programming, NP-completeness, and linear programming. Theory of computation: automata, formal languages, and the classes P and NP.
Phase 4 · Weeks 16–18 — Continuous Physics and Geometry
Classical mechanics: Newtonian dynamics, oscillations, conservation laws, the Lagrangian method, and normal modes. Differential geometry of curves and surfaces: curvature, fundamental forms, Gaussian curvature, and geodesics. Electrodynamics and optics: Maxwell’s equations, electromagnetic waves, geometrical optics, diffraction, and Fourier optics.
Phase 5 · Weeks 19–20 — Algebraic Structures
Groups, subgroups, Lagrange’s theorem, homomorphisms, and quotient groups. Rings, ideals, and fields. Polynomial rings and irreducibility. Extension fields via \(F[x]/(p(x))\). The structure theorem for finite fields (\(\mathbb{F}_{p^k}\) unique up to isomorphism) and the Frobenius automorphism. Applications to RSA, elliptic curve cryptography, and algebraic error correcting codes.
Course 6 — Microelectronic Circuits & Signal Processing: Theory to Bench
A 10-week bench-based course connecting field theory, circuit theory, microelectronics, and signal processing into one continuous, hands-on story. Every circuit is predicted by hand, simulated in SPICE, and measured on real instruments (Fluke 117 multimeter, FNIRSI LCR meter, Siglent 100 MHz oscilloscope) on a breadboard, with the Jetson Orin Nano as the data-acquisition and DSP target. Primary resources: Ulaby & Maharbiz Circuit Analysis and Design, Scherz & Monk Practical Electronics for Inventors, Platt Make: Electronics, Griffiths Introduction to Electrodynamics, and Oppenheim’s Signals and Systems and Discrete-Time Signal Processing.
Phase 1 · Weeks 1–4 — Circuit Foundations and Bench Skills
From Maxwell’s equations to the lumped-circuit model: charge, current, voltage, Ohm’s law, and multimeter fluency. Resistive network analysis — KCL/KVL, nodal, mesh, superposition, Thévenin/Norton. Capacitors and inductors from field energy down to ESR measured on the LCR meter. First- and second-order transients captured on the oscilloscope: time constants, damping, and ringing.
Phase 2 · Weeks 5–7 — AC, Frequency Response, Filters, and Devices
Sinusoidal steady state, phasors, impedance, and AC power, with amplitude and phase measured on the scope. Frequency response and analog filters: transfer functions, Bode plots, resonance, and quality factor — measured point by point. Semiconductor devices: diodes, BJTs, MOSFETs, and op-amps put to work as rectifiers, switches, amplifiers, buffers, and active filters.
Phase 3 · Weeks 8–10 — Signal Processing: Continuous to Discrete
LTI systems, convolution, and the Fourier transform — the framework that explains every circuit measured so far. Sampling, aliasing, ADCs, and reconstruction, with aliasing witnessed live and an anti-alias front end built for the Jetson. Discrete-time signal processing: the z-transform, FIR/IIR digital filters, and the DFT/FFT. Capstone: capture a real signal, filter it digitally on the Jetson, and reconcile the digital filter against its analog twin.