Twelve Years of This Journal: Looking Back

When I posted the first entry in this journal back in February 2014, I was writing about Composer. Moving from manually including modules to proper dependency management was a real shift at the time. Small but concrete. A short, practical note in the vein of “here’s how I’m doing this.”

Between that first post and this one, one hundred and forty-eight entries went by. Every month, for twelve years. Some months were hard — not because I couldn’t find a topic, but because I couldn’t find the time or energy to write. Still, I kept going. Writing this final entry and looking back feels both natural and necessary.

What Changed, What Stayed

In 2014, I was a PHP developer. In 2026, I’m still a PHP developer. On the surface that might look like nothing changed — but everything underneath is different.

Back then I was looking for solutions: “how do I build this feature, what does this library do, how do I use this framework?” The posts followed those questions. Finding something that worked was enough.

Later, the nature of the questions shifted. Instead of “how do I do this,” I started asking “why this approach, what are the alternatives, what’s the cost?” Seeing trade-offs was a sign of the Senior stage. Learning that there’s no single right answer — that context drives the decision.

In recent years the questions have moved further still. “Is this system coherent? Is this decision freedom now but a constraint later? Am I building something someone else can understand?” I no longer want to write a single feature; I want to write something that can keep living over time.

These three stages are readable in this journal too. The posts from the early years are concrete and tool-focused. The middle period is about decisions and comparisons. The later period is quieter, speaking in broader patterns.

A Few Turning Points

Looking back, some posts carry an unexpected weight.

The Go post from 2019: what started as a small experiment under the title “Why I Started Learning Go” has since earned a permanent spot in my toolbox. When I wrote that post, I had no idea it would turn out that way.

The ChatGPT post from 2022: my note reads “first impressions — excitement and an honest assessment of the limits.” The posts from the years that followed show where that excitement went; how AI changed the developer’s job, what it upended, and what it still left standing.

The “filtering the hype” post from 2023: the person who wrote that and the person in 2014 who got excited every time he heard about a new framework are the same human. But the reflex is different now. Instead of chasing every new thing, I ask what problem it actually solves first.

On Being Polyglot

I started this journal with PHP and I’m ending it with PHP. But Go and Python found their way in between. That wasn’t a deliberate decision — problems brought them. Go for command-line tools and small services, Python for automation and data processing.

Here’s what I learned: knowing one language deeply doesn’t prevent you from looking at others; it actually makes it easier. The depth I built in PHP meant I could spot what was different in Go much faster. The ease of scripting that Python brought made me better at avoiding unnecessary complexity when writing PHP. Languages feed each other.

On Writing

Beyond technical knowledge, this journal’s other contribution was making writing a habit.

The obligation to write something every month — I imposed it on myself, but it felt like an obligation — developed the discipline of externalizing thought. Things I thought I understood before sitting down to write them turned out to be incomplete or just wrong once I actually started. That correction loop was for me far more than for the posts themselves.

I also saw the career effect of being a developer who writes, in time. A résumé tells what you’ve done; writing tells how you think. That difference seems small, but it compounds over the long run.

Closing

I’m writing the last post in this journal. “Last” is a heavy word, but it’s the right one. Twelve years of writing something every month is complete.

The distance between the developer who was learning to use Composer in 2014 and the one writing this today isn’t just time. Dozens of projects, hundreds of mistakes, a few languages, a few platforms, a lot of decisions. This journal became a record of that distance.

I don’t know what comes next. But it will begin carrying everything these twelve years have built.