Diiv.io
I’m currently a staff software engineer at Apple in the Apple Services Engineering org, working on distributed systems and mobile device management. Find me on LinkedIn, X / Twitter, and GitHub.
On the academic side, I hold a B.S. in EECS from UC Berkeley and an M.S. in Computer Science from Georgia Tech. My Berkeley EE coursework centered on signal processing, systems, random signals, and convex optimization. The CS half of the EECS degree, like my Georgia Tech master’s, focused on artificial intelligence and machine learning, alongside computer networking, security, operating systems, algorithms, and compilers.
This site documents a focused, self-directed multi-weekend project: learning about via real practice on digital signal processing for embedded software / firmware engineering and real-time rendering and GPU engineering. It’s built as one comprehensive math theory course followed by three courses, a DSP course, a course on computer architecture and ARM assembly, and a lab-based rendering/GPU course.
My full-time job and commitments to my family like my amazing wife always come first, so this is a hobby-outside-work project I build on weekends, likely over 1–2 years to complete. Updates are slow by design, but when I do publish, I make sure to only put up content I feel is of solid quality.
Everything of substance here is done by hand, because the whole point is to learn. The math proofs and exercises are worked out by hand, and so are the labs and their associated write-ups once I actually do them. The only thing AI provides is this skeletal structure: the page scaffolding and consistent formatting, plus typesetting my handwritten proofs into LaTeX/KaTeX. Nothing beyond that skeleton is AI-generated.
The courses
Course 1 is the mathematics: the theory prerequisite, worked by hand. Course 2 is the programming prerequisite: language and library fundamentals in the three languages every lab is written in — scientific Python (NumPy, SciPy, PyTorch), modern embedded C, and embedded Rust — in the rhythm the labs assume, where an algorithm is prototyped and verified in Python first and then implemented in C or Rust on the tier it runs on. Course 3 is the bench: a fully lab-based course that spends that theory and those languages building, measuring, and shipping real-time DSP on real hardware; Course 1 is assumed mastered and applied there, never re-taught. Course 4 points the same foundation at a second craft: real-time rendering and GPU engineering — modern C++20, Vulkan, Metal, and CUDA, fully lab-based with a profiler open on every lab.
Course 1 — Math Foundations for Signal Processing, Machine Learning, and Artificial Intelligence
A single self-contained booklet, Abridged Math Foundations for Signal Processing, Machine Learning, and Artificial Intelligence: 45 lessons in 7 parts, dependency-ordered. Linear algebra through the spectral theorem, the DFT as a unitary matrix, the SVD, and determinants; probability through conditional expectation, random and Gaussian vectors, limit theorems, Bernoulli/Poisson processes, and Markov chains; signals and systems — convolution, Fourier series and transforms, frequency response, sampling, Laplace and \(z\)-transforms; the analysis behind the transforms — Lebesgue integration, Hilbert spaces and \(L^2\), complex analysis, distributions, and numerical linear algebra; and convex optimization and information theory — convex models, regularized fitting, duality and KKT certificates, gradient/Newton/proximal algorithms, entropy, KL divergence, mutual information, channels, and rate–distortion. Each lesson: theory with proofs, practice by hand, and [Proof]/[Hand] exercises worked by hand; per-lesson deeper-reading pointers resolve to the textbooks on the Books page.
Books: Axler Linear Algebra Done Right · Trefethen & Bau Numerical Linear Algebra · Ross Elementary Analysis · Axler Measure, Integration & Real Analysis · Bertsekas & Tsitsiklis Introduction to Probability · Bak & Newman Complex Analysis · Strichartz A Guide to Distribution Theory and Fourier Transforms · Kreyszig Introductory Functional Analysis with Applications · Dunn & Parberry 3D Math Primer for Graphics and Game Development
Course 2 — Programming Foundations: Scientific Python, Modern Embedded C & Embedded Rust
Thirteen modules in five parts. Scientific Python — the ndarray memory model, broadcasting and vectorization, scipy.signal/fft/linalg/stats, Matplotlib, the audio/image/video libraries, scikit-learn, and PyTorch from tensors and autograd through hand-written training loops to quantization, ONNX export, and inference on the Jetson — with the ctypes and PyO3 bridges that let a C or Rust kernel be checked against its Python reference. Modern embedded C — the C99/C11 subset pinned as C17/18, integer promotions, layout contracts, restrict, _Generic, volatile and memory-mapped I/O, static allocation, the undefined behavior that matters, interrupt-safe sharing, FreeRTOS, and POSIX on embedded Linux. Embedded Rust — ownership and Result for a C programmer, no_std on the Cortex-M with cortex-m-rt, embedded-hal, Embassy, and RTIC, Send/Sync and unsafe contracts, and std Rust on the Jetson — every concept shown in both languages on three runtime tiers (bare metal, RTOS, embedded Linux), verified on the Mac (sanitizers, Miri, QEMU), deployable to the STM32 and the Jetson. Capstone: one sensor driver written three times — Python reference, C17, Rust — and built for all three tiers.
Sources: the NumPy/SciPy/Matplotlib/PyTorch documentation and the UvA notebooks Introduction to PyTorch · Seacord Effective C, 2nd ed. · Klabnik & Nichols The Rust Programming Language, 3rd ed. · the Embedded Rust Book, Embedonomicon, RTIC and Embassy docs · Mastering the FreeRTOS Real-Time Kernel · Grenning Test-Driven Development for Embedded C · the course’s Modern C for STM32 Firmware reference guide
→ Syllabus
Course 3 — Embedded DSP: From the Bench to Real-Time Firmware
A fully hands-on, lab-first course (~46 labs across 8 core modules + two bonus modules) that turns the math into working firmware. Bench instrumentation and safety; mixed-signal I/O (I²C DAC/ADC, level shifting); analog signal conditioning with op-amps; interrupt- and DMA-driven acquisition on an STM32 Cortex-M4F; real-time FIR/IIR filters, the FFT, PSD/noise-floor estimation, Goertzel tone detection, and Kalman state estimation; robust RTOS firmware; learned, on-device signal processing on a Raspberry Pi 5 and a Jetson Orin Nano; and a host-in-the-loop workflow that streams real audio/image/video files to the target, processes them, and verifies the result against a reference. Every circuit is predicted by hand, measured on real instruments, and reconciled.
→ Syllabus
Course 4 — Real-Time Rendering & GPU Engineering: Vulkan, Metal & CUDA in Modern C++
A fully lab-based course (33 labs across 8 modules) pointing Course 1’s mathematics at real-time 3D graphics: the graphics pipeline learned twice, with every scene rendered through both Vulkan (modern C++20 under CMake) and Metal (Swift, then metal-cpp); general-purpose CUDA programming in C++ and Python on a Linux desktop’s RTX 4090; an engine grown lab by lab — resource lifetimes, a render graph, multithreaded command recording, culling and instancing; the techniques modern renderers are made of — cascaded shadow maps, deferred shading on tile-based Apple GPUs, quadtree terrain with streaming, GPU-driven rendering, Gaussian splatting; and performance engineering as a first-class subject, with Tracy, Xcode GPU capture, RenderDoc, and Nsight on every lab and a capstone world viewer shipped on two APIs and two GPUs with a written performance report.
Books: Begbie & Horga Metal by Tutorials · Castorina & Sassone Mastering Graphics Programming with Vulkan · Motta GPU Programming with C++ and CUDA · Halladay Practical Shader Development · Lengyel Mathematics for 3D Game Programming and Computer Graphics · Dunn & Parberry 3D Math Primer for Graphics and Game Development
→ Syllabus
Book proofs & notes
I work through selected proofs and exercises by hand on paper first. Once I’m satisfied with a solution, I typeset it in LaTeX/KaTeX; the typesetting is the only part that is AI-assisted. Everything is organized by book and chapter in Books.
- Math (Course 1) — Axler (Linear Algebra Done Right), Trefethen & Bau (Numerical Linear Algebra), Ross (Elementary Analysis), Axler (Measure, Integration & Real Analysis), Bertsekas & Tsitsiklis (Introduction to Probability), Bak & Newman (Complex Analysis), Strichartz (A Guide to Distribution Theory and Fourier Transforms), Kreyszig (Introductory Functional Analysis with Applications), Dunn & Parberry (3D Math Primer for Graphics and Game Development)