December 07, 2025

10 Years

This post marks the tenth year of my technical blog. I started in 2016, ended up writing exactly 9 posts during that year, and made it a point to consistently stick to that number. You are reading post #90. This will be a self-indulgent look back at the past decade.

Why 9 posts per year? While sometimes I have plenty of things to write about, other times I get busy and don’t have the time. Maybe something like a post per month would’ve been nicer, but harder to achieve. I’m still happy I was able to stick to this for so long.

I started self-hosting the blog on my own engine, Tinkerer, which is now archived here. Tinkerer relied heavily on Sphinx and Jinja, relying on the Sphinx plugin system to turn it into a blog. Extensions provided post metadata, ordering and pagination, RSS-feed generation and so on. That worked well until it didn’t. Updates to Sphinx irrevocably broke things, plus Markdown was gaining momentum - who even remembers the cumbersome ReStrctured Text syntax? I implemented Baku, the spiritual successor to Tinkerer, and used PanDoc to migrate my old posts from RST to Markdown.

Baku, which I’m using to this day, is here. It completely drops the Sphinx dependency and replaces Jinja with a 100 LoC templating engine which I’m still very proud of - my VerySimpleTemplate. Lesson learned: the fewer dependencies the better.

Throughout the years I covered various topics I was digging into at the time. When I started the blog in 2016, I was working on the Office C++ clients. The very first two posts are based on a Clean Code talk I used to do (see Clean Code Part - 1 and Clean Code Part - 2).

I was digging deep into modern C++ at the time. Some posts, like Arguments and Smart Pointers and Notes on Types provide best practices. Others covered some of my own R&D. A version of the efficient stack-allocated data structure I describe in (Ab)using Maps made its way into the Office core libraries and became a standard for applicable scenarios. The Composable Generators post became this small library that enables generator chaining in C++: https://github.com/vladris/pipe. This was back when generators were still an experimental language feature.

Around that time, I was starting to dig into types and type systems. I wrote an initial Notes on Types post, and a while later one covering the Idris programming language - Idris: Totality, Dependent Types, Proofs. Then Notes on OOP and Clean Code: Types, all around the topic of types. This became my first published book, Programming with Types in 2019.

Several posts from around that time were topics that I was researching and which made their way in the book, like Arithmetic Overflow and Underflow and Notes on Encoding Text, or excerpts from the book once it was ready:

I switched jobs in 2019, going from Office to Azure and trading in C++ for data platform architecture. My first post on the subject was Notes on Data Engineering. It was a new space for me, with plenty to learn, and during 2020 I wrote a bunch about it:

Like the previous type rabbit hole, I ended up publishing Data Engineering on Azure in 2021.

At the same time, I switched teams again, moving from Azure back to Office to work on Fluid Framework and then Loop. I wrote the first Mental Poker post in December 2021, while thinking through how one could implement a game over Fluid Framework. This became an on-and-off side project which resulted into the Mental Poker series of posts:

I wrote these over the span of two years, from early 2023 to late 2024, while creating this open source library: https://github.com/vladris/mental-poker-toolkit.

Before Mental Poker, I spent 2022 digging into computability. I always found the subject fascinating:

After wrapping up the Mental Poker toolkit, I spent 2025 implementing a text editor and wrote several DevLog posts about it - Flow, Formatting, Commanding, Theming and Footguns, Markdown and WYSIWYG.

Sometime in 2023, when GPT3 took the world by storm, I wrote another book, Large Language Models at Work. I didn’t publish excerpts on my blog as I made it freely available at https://vladris.com/llm-book. Fun fact, the book website is also built using Baku, just like this blog.

The industry moved fast, and what was state of the art in 2023 became mostly obsolete by 2025. I reflect on that in Agent Integration Patterns.

With the holiday season coming, I’m excited about Advent of Code. I’ve been solving puzzles since its inception and since 2023, I made it a tradition to start the year with a post covering the past December’s Advent of Code, focusing on the problems I found most interesting.

Not everything requires series of posts, sometimes I write a self-contained just-for-fun thing. Like how I implemented a digital pendulum clock, a solver for an iPhone game called Kami 2, or a solver for the game 24. Or that time I implemented Timsort to get a better sense of how it works.

The above is not a complete list of what I wrote here over the past 10 years, rather a recap of some of the major themes. It’s been a fun ride so far. As for the next 10 years - who knows? I know my next post will cover Advent of Code 2025. The sky is the limit beyond that.

I have plenty of things I still want to cover:

Happy holidays and see you in 2026! Thank you for reading!