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, a programming-foundations course delivered as three 100-exercise GitHub repositories, a lab-based embedded-DSP course, 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, with one disclosed exception: the exercises in Course 2’s three repositories are AI-drafted, and I work through and correct them one at a time — each README carries a dated status note saying how far my own hands have got.
The courses
Course 1 is the mathematics: the theory prerequisite, worked by hand. Course 2 is the programming prerequisite, delivered as three 100-exercise GitHub repositories: modern embedded C (the C of the firmware labs), modern C++ and CUDA (the language of Course 4), and NumPy and PyTorch (the Python every lab prototypes in) — solved one self-contained, test-checked file at a time. 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, and Metal, 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: 70 lessons in 9 parts. Linear algebra through the spectral theorem, the DFT, and the SVD; probability, random vectors, limit theorems, and Markov chains; signals and systems; the analysis behind the transforms — integration, Hilbert spaces, complex analysis, distributions; convex optimization and information theory; neural networks and deep learning; and the mathematics of real-time rendering. Each lesson pairs theory and proofs with practice by hand, ending in [Proof] and [Hand] exercises.
Course 2 — Programming Foundations: Modern Embedded C, Modern C++ & CUDA, and NumPy & PyTorch
Three 100-exercise repositories on GitHub, each in the format of Mainmatter’s 100 exercises to learn Rust: one self-contained file per exercise that states a problem and tests the answer, a next command that runs the first unfinished exercise, and a reference solution to diff against once you have a failing attempt of your own. Modern embedded C — C17, the C of shipping firmware, 100 host exercises under the sanitizers with an MCU’s budgets plus a bare-metal track on the NUCLEO-L476RG — is the C of the Course 3 labs. Modern C++ — C++20 in 100 exercises, then 25 more on modern CUDA C++ built on the RTX 4090 Linux desktop — is the language of Course 4. NumPy and PyTorch — 100 exercises from broadcasting to a capstone character-level transformer — is the Python every lab prototypes in. For these repositories only, the exercises themselves are AI-generated: the exercise files, starters, tests, and reference solutions were drafted with AI assistance from the books each README lists. I am solving them one at a time by hand, fixing what I find, and each README carries a dated status note saying how far I have got.
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 in Modern C++
A fully lab-based course (28 labs across 7 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), on a Mac and a Linux desktop’s RTX 4090 — the CUDA compute foundations are worked beforehand in Course 2’s C++ repository; 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.
→ 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)