Blog

Developing Software in the Face of Uncertainity

A process I built from first principles inspired by Pixar, physics, and drawing classes — for building software when you don’t know what the final design should be yet.
This is about exploring assumptions with small experiments, reducing scope until everything becomes tractable, and designing after you have real knowledge instead of imaginary certainty.
One of the most universally applicable engineering ideas I’ve ever written.

Five Lessons in 2023

A snapshot of a year where my entire approach to software matured.
From ShapeUp vs Scrum, to why unit testing is really about collaboration, to reframing test taxonomies around properties, these lessons still shape how I build systems today.
This post aged better than I expected —especially in a world where teams are constantly renegotiating how to build software together.

Modern C++ Stack

A deep dive into how I built a modern C++ workflow using CMake, gtest, Eigen, OpenCV, and Qt and why C++ doesn’t have to feel like a chaotic 1990s build nightmare.Still one of the cleanest end-to-end explanations of “modern C++ project structure” I’ve made.
This is the post I wish existed when I started doing real C++ work.

Planning an Electron Side Project

A story about rebuilding momentum by shrinking scope, validating assumptions fast, and using experiments to guide design rather than planning too far ahead.
It’s part engineering process, part personal creativity reboot, part reminder that small wins matter.
This one resonates with anyone who’s ever been stuck on a side project.

Object Oriented Taxonomy

My attempt to explain why naïve OOP makes developers act like taxonomists instead of problem-solvers.
I contrast “classification-heavy OOP” with data + processors (inspired by FP) and show how this leads to cleaner, more flexible systems.
Still one of my favorite pieces on design philosophy and one of my most controversial.

Extending Type Systems

My hybrid method for bridging the gap between testing and formal verification:
Treat unit tests as axioms, use theorem provers for higher-level correctness, and let the two approaches reinforce each other.
This was the earliest seed of my current work on linear logic and structural reasoning. It’s surprisingly prescient.

Spacy Relation Extraction

A practical walk-through of implementing an Open Information Extraction algorithm using spaCy not a black-box demo, but a real explanation of pattern matching, span merging, and linguistic constraints.
Still gets me emails.
If you want to understand how to extract structured triples from text, this post is exactly what you need.

Software Developer Licensing

A thought experiment about what would happen if software were treated like other licensed professions — and what core competencies we’d actually test.
Correctness. Abstraction. Complexity.
It’s not about gatekeeping — it’s about raising standards in a world where software failures have real consequences.
This post remains surprisingly relevant today.