I built this while studying for my undergraduate degree, after taking Udacity’s free Interactive 3D Graphics course with Eric Haines . I entered the course demo contest and won the Best Animation category . The project inspired me to learn more about frontend development, shaped the feel I want for the software I produce, and led me toward building the APE rigid body physics engine for my undergraduate thesis.

I built APE as my undergraduate thesis after learning computer graphics with Three.js. I used it to study how physics and mathematics become a simulation, including how F = ma connects acceleration to velocity and position through integration. The thesis develops the theory of position, velocity, acceleration, and mass, then implements integration, collision detection, and collision resolution before demonstrating the engine in a billiards game.

I was learning JavaScript and wanted a better way to visualize the code I wrote. I built a tool that analyzed JavaScript object structures at runtime by following objects and their prototypes, including the __proto__ inheritance model used before JavaScript classes. The project taught me that typeof Function.prototype is function, that some objects in window are read-only, and that many array-like objects exist deep in the window object graph. PojoViz was later featured in JavaScript Weekly issue 194 , which showed me what was possible when I was ambitious enough to build and share an idea.

I started this blog as a space to write notes for myself. Over time, I added animations and interactive elements so the notes could live in a format that felt natural to me. I like knowing that what I write can share a small part of my mind with the rest of the world.

I first learned about convex hulls while practicing for the ICPC contest during my undergraduate studies. Later, I learned that convex hulls can reduce the geometry sent to physics engines such as APE. When I looked at the JavaScript ecosystem, I could not find a performant implementation, so I ported a popular Java implementation and optimized it for JavaScript primitives such as ArrayBuffer. The library became the fastest convex hull implementation in the JavaScript ecosystem. It was later incorporated into Three.js, where the new implementation reduced the runtime of finding convex hulls from quadratic time to n log n in this pull request .

When I started this blog, I decided to learn the fundamentals needed for computer graphics and physics engines. That path led me to learn and write about derivatives , calculus, and related topics. I wanted to represent derivatives visually, but I could not find a library in the D3.js community that did this. I first wrote an inline D3.js script and then realized I could build an API around it. function-plot grew out of that experiment. This became one of the most complex projects I have worked on. A 2D plotter looks like a function sampler, but handling asymptotes and rapidly oscillating functions requires much more. I learned that plotting correctly is tied to how computers represent numbers and lose precision in values such as 1/3. That led me to write interval-arithmetic , which works with intervals instead of individual numbers. I then wrote a parser from scratch to turn expressions such as x^2+x-3 into executable JavaScript using interval arithmetic. I am still working on function-plot more than ten years later, and it continues to evolve with new features. The project has also brought me opportunities to meet one of the early employees of Figma and visit their offices, and to connect with the author of GeoGebra , one of the leading products for teaching mathematics.

While working on function-plot, I learned that rendering a function correctly was a numerical problem, not only a visualization problem. I wanted the plotter to provide reliable bounds for every part of a curve, so I needed arithmetic that carried uncertainty through each operation. That led me to learn interval arithmetic and build this implementation. Calling interval methods directly quickly became cumbersome for complex expressions. Writing sin(exp(x)) + tan(x) - 1/cos(PI) * [1, 3]^2 as nested method calls obscured the mathematics, so I also created an interval arithmetic evaluator that parses expressions and evaluates them over intervals. That evaluator became part of the path from a string such as x^2+x-3 to executable JavaScript in function-plot.

I decided to learn more about graph theory and wanted to see algorithms unfold instead of only reading their descriptions. Once again, I could not find a JavaScript library with the interactivity I wanted, so I started with a D3.js script and then realized it could be abstracted into an API. I like that the API is declarative. You describe the nodes and edges you want, and the library makes the graph match that description. Later, I recognized this as a control loop: the system repeatedly reconciles the actual state of the graph with the desired state. Looking back, this gave me an early intuition for the controller pattern I would later encounter in Kubernetes controllers . The project became popular enough to reach the top of Hacker News in 2015, which is still one of the things I enjoy most about this project.

As I started using the terminal more and working across many projects, I needed a consistent environment that I could control and reproduce. I began adopting the tmux , Zsh , and Neovim trinity, then grew these dotfiles around them. The repository now includes an automated, modular installer and configurations for tools such as Ghostty, Git, Go, Python, Rust, and Zellij. It remains a work in progress, and I document more of the workflow in my productivity notes .

As I learned about Kubernetes , I started writing small applications and experiments to teach myself how it works. The projects cover topics such as controllers, Kubernetes storage internals, and how kind works under the hood. The repository became a place to turn questions into runnable examples and notes.

I learn languages and use Anki on my phone to keep the habit going. I started collecting new words and saving them in Anki so I could review them whenever I had an opportunity. That practice helped me reach an intermediate level in French, and it is now helping me learn Japanese too. These decks and skills are the material I use to make that process more effective.

I use YouTube as my main teaching platform. When I watched Japanese videos with subtitles, I wanted more context than the player provided: furigana alongside translations, explanations that could be generated in the browser, and a way to pause automatically at the end of a sentence so I had time to study what was said. Subtitle Insights grew into a local, privacy-first Chrome extension that turns videos into interactive lessons. Its smart sidebar stays synchronized with the transcript, and its pause-on-hover controls support shadowing and focused study. This was one of my first projects where I used AI beyond writing code by hand or asking for isolated snippets. I used the then-available Conductor extension for Gemini to iterate quickly on the extension over a few weekends.

I made EPUB Translation to translate books I want to study into another language, such as French. It lets me learn a new subject from a book while learning the language at the same time, and preserves the structure and formatting of the EPUB along the way.

I do ab exercises regularly and got tired of listening to the same songs in the YouTube routine I followed. I built this with AI Studio and added features I wanted for myself, including multiple difficulty tiers, a calendar tracker for motivation, mood-based playlists, and support for additional weights. I now use it to track pushups and squats too.

Rats appear all the time in New York City, so I decided to turn spotting them into a small game. Whenever I see one, I record it in RatTrack and can later explore the locations on a map and see where I have found the most rats through a heat map. The app also includes sightings from Boston and Paris.

I built this AI Studio app to develop intuition for serving large language models. It helped me explore metrics such as TPOT, TTFT, and TPS, the hardware involved, input and output sequence lengths, inference server configuration, and deployment flags such as tensor parallelism and data parallelism.

I wanted a simple Linktree clone for collecting my links. Since it is my own page, I also embedded a few videos of my performances on YouTube.