Most of the time, I try to keep this blog/mailing list to thoroughly thought-through articles about software development: mostly, programming languages in general and Ruby in particular.

But after it was dormant for quite some time, this one will be a bit more personal. And a lot less coherent.

For those who just wandered into this blog post on my site, or those who have subscribed to my mailing list and forgot what that was about (I get it! I wasn’t writing anything for months!), just a quick reminder: I am a software developer and writer from Ukraine, currently serving in the military. You can look up my personal site for some of my writing, projects, and talk recordings.

This blog/mailing list didn’t see me writing with any kind of consistency for the best part of the last two years. There are reasons for that – and there are reasons to write again, or at least try to.

This text is my attempt to reflect on what to write in these weird times, to focus on what still makes sense to write.

But first, I want to mention a few things I did write last year. Ruby-related and not (so much not, they aren’t about software development at all).

Writing in 2025

Christmas 2025 saw the release of Ruby 4.0: a new “major” version of my primary programming language for 20+ years; the one for which I am a proud (if minor) committer. While I didn’t participate much in the language development this year (other than an occasional issue tracker discussion), this December I traditionally made an annotated changelog for it.

I do for the eighth year in a row and have covered the changes in the freshly released version since Ruby 2.6 (and also expanded it to couple of prior versions and made a bird’s-eye-view Evolution page, briefly listing “all notable changes since Ruby 2.0”).

The “annotated changelog” only covers the language (syntax, semantics, and API) changes. While the latest version doesn’t have as much as “major” version change would imply (Ruby doesn’t follow semantic versioning, and this year’s number change is just to celebrate the language’s 30th birthday, according to Matz), the format I set to myself – every change tested, explained, and demonstrated – required quite a lot of work. As usual, going through the new and updated stuff made me notice where the behaviors weren’t clear or documentation was lacking; to make this part of the work more visible, I decided to mention it in the afterword of the changelog since this year.

Aside from this work – and a couple of stray blog posts, which I’ll explain a bit later – I spent my rare free time translating modern Ukrainian poetry, written by authors serving in the Ukrainian Armed Forces, for my personal project 7uapoems. I rarely mention it in my programming-related blog, but maybe some of my readers would be interested – I constantly find myself surprised by how many technical people are actually into poetry and literary writing in general.

Speaking of which (but probably not of interest to 90% of the readers), this year I also finished my new Ukrainian novel in Ukrainian, and saw my first published one gaining some readership.

At least, that explains how my writing muscle was occupied throughout the year (or, what my graphomania was channeled into, if you will).

Not writing in 2025

I still feel uneasy about all but abandoning the blog/mailing list – and that at the times when it gained some solid audience. You, my reader: my several hundred of mailing list subscribers. Which is, of course, a tiny number in modern megalomaniac internet, but enough for me to feel “I am talking to real people, not just screaming into the void.”

So, why DON’T I actually talk?

The above section might’ve been some explanation: I wrote a lot last year, just in other media/on other topics, but it is not the full explanation.

Another one, is of course, the war. I am a serving officer, and while I am serving as a software developer, too – this still limits my time and free mind resources for writing. It was a hard year for Ukraine, for many reasons which you either already know or didn’t care enough to learn. My team, though, achieved quite a lot – but the details I, for the time being, can’t share. Neither the particular things we’ve done, nor insights related to those achievements. My primary language/domain in this role is different now (Python and data processing), but on the projects, practices, and achievements my lips are sealed.

But even this is not the full explanation for a dormant blog, to be honest.

The thing is, I have only two “regimes” of writing. The first one, which, unfortunately, activates pretty rarely, is “write down a quick idea/experiment/explanation that you just thought of.” The trick here is to match a reasonably small idea with enough free time to write it down immediately. Otherwise, it might turn into something that I either consider too trivial, or, on the contrary, something that should lead to a deeper investigation and more detailed explanation of the matter, or more comprehensive implementation of an idea.

Because my second – and, unfortunately, primary – regime of writing is to follow some long train of thought, or overarching idea, or explaining a reasonably large domain. My head just works like that. When I still wrote poems (which is a short and self-sufficient form), I, for decades, only wrote them in “cycles” of ten to twenty texts, which might’ve been diverse in tone and style but still were part of some internal plan and intention.

And when you do this – planning to write a series on some topic/area – with programming-related blog posts, the things get complicated. Without enough feedback (or, with a lot of negative feedback) it is quite easy to decide to just drop the topic. My blog is shamefully full of posts that claim to be the start of a large series – even including something like “Part 1” in its title; there is also a fair share of “course correction” reflective posts (like this one) to claim “I understood what I want to write about now,” with no follow-ups.

Sometimes there are “series” that I planned and executed till the end. Sometimes, again, without enough feedback or understanding whether there is an audience (like Rebuilding The Spellchecker).

Other times, I pull this up successfully. The last of such successes was the cheeky-named “Useless Ruby sugar” in autumn 2023 – which, actually, started as an article of the “first type”: quickly triggered response to someone on the Reddit, to explain why “useless syntactic sugar they add to our language” is not that “useless,” and grew into two months of weekly structured posts.

This one accidentally became quite successful – and at the moment, it felt as if both my expertise and my way of looking at things were important to this success. As was my fascination with the story of a language evolution – a programming language evolution, in this case, but taken from “how it makes us think and write.”

So, after that, I had this idea about a corpus of texts – blog posts or even a book, maybe? – on Ruby’s evolution. Some crossover between that changelog I maintain and the “‘useless’ sugar” series, to try to tell a coherent story of how the language takes shape and changes with time. I did a few approaches to the idea (1, 2, 3)… and quite quickly understood there just isn’t a vibrant audience for this kind of content. At least, not among the readers who stumble upon my texts – maybe somewhere in academia? – anyway. In the autumn of 2024 I reviewed the series/book idea critically – and then dropped it altogether.

Then, in 2025, I had some vague yet persistent chain of thought about the similarities of working with code and working with texts in human language; the width and depth of it seemed promising (and speaking to a wider programming community than Ruby-related texts). It never caught enough wind though, two posts boldly named week 1 and week 2 (plus an unfinished draft of week 3) is as far as I got before understanding that the overarching idea is too broad to speak to anybody in particular. Maybe, it should’ve been approached differently. Maybe, it will.

Or maybe it all – my attention to language nuance, my belief that good software grows from well-written “phrases” – will become irrelevant, and quite soon.

For the last couple of years, people seem to stop writing code by themselves.

A brief diversion: my views on AI

I wouldn’t try to make a comprehensive write-up on everything I think on the large area of tech that goes under the “AI” shortcut. I was always interested in the technological/scientific part of it, frequently worked in adjacent areas (hell, my first full-time software development employment in 2003 was several months working on a small startup that tried to apply those days neural networks to stock market prediction or something); and, while not being an insider of this part of the industry, I have a whole lot of thoughts and opinions formed through past decades.

But for the sake of this particular text, it is enough to say this: I still feel kind of childish wonder in front of a technological part of it, of the intelligence illusion which emerges from the simple math. And unlike Baldur Bjarnason, whose book title I am quoting here and for whose opinions I have a lot of respect, I use “illusion” here in a less-than-derogatory sense: when you look at a purely technical side of things, it is somewhat fascinating how the unpredictability of the human thought can be imitated by matrix multiplication.

At the same time, I am as much horrified as everybody else with the economic and societal consequences of what the current iteration of unregulated mega-corporations, hype cycle, and malevolent power players do to our world using those technologies. I am not sure whether it is a “bubble” that will “pop” at some point; I will abstain from any attempt to extrapolate “where is it going” – but overall, the “AI future” doesn’t look bright.

One thing, though, seems to me if not inevitable then at least highly likely: the change that LLMs and generative AI bring to all kinds of “informatics-related” work (any kinds of creation, maintaining and changing any “intellectual property,” be it art, news, or programming) is pretty similar to industrialization of the early XX century.

I mean that, for example, software development, even in huge international corporations, was more like “craft” just a few years ago. I say “craft” not as a synonym of “art,” but in a medieval sense: hand work of highly and narrowly qualified professionals, with guilds, apprenticeship, and significant impact of personal traits on the end product. Even if the “guilds” grew into extremely large international corporations, making personal impact in many particular cases as negligible as “cog in the machine,” the impact still stayed personal.

Now, it is about to change – already changes. LLMs take a role of the “machines” in an information-related “production.” No analogy is perfect, but this one seems to give a lot of predictions and explanations. Like: “aren’t machine-made products inferior?” – many might be, but in a lot of situations, 100 shitty plastic chairs produced in a day will be preferred to one sturdy and polished wooden one, produced in a week. Or: what will happen to the “craftsman” of yesteryear? In imaginary factories, some of them will become engineers, others – low-valued machine operators. Some will continue to do what they’ve done: there is still room for handiwork in today’s world: producing artisan unique items, or, vice versa, quick-fixing broken tables for local grandmas; or, semi-manually creating R&D prototypes for future machine implementation. But there will be much less demand for this kind of work.

To be clear, this is not an optimistic, progress-embracing view. Industrialization of the XX century saw a lot of unfairness – due, in part, to shifting the balance of employer/employee relationship. This time, it might be much worse, considering *gestures vaguely at everything*. We are used to using “Luddite” as a dismissive term for “those who don’t understand the virtues of progress.” But we – some of us, anyway; many of us, probably – are about to learn what was their point. In a hard way.

Maybe writing in 2026

The lengthy rant above might seem out of place in this personal post (I acknowledge that it is a shortened version of a separate “what I think about AI” article draft). However, the changing landscape directly affects the topics that make me passionate enough to write programming-related texts.

My main idea always was thinking about code writing as I think about text writing. Thinking at the level of a singular phrase, that affects the way the underlying structures are built and how the language is used and evolves. The optics I sometimes like to call “lucid code.”

Even before the advance of LLMs, this way of thinking was a hard sell. The frequent consensus is that architecture and high-level structure of the program are the things that matter, while the code underneath is “just boring details.” Surprisingly, though, my ways of thinking, when battle-tested on complicated production projects, tend to show its benefits for velocity and maintainability. With years, I learned to explain it better.

But the tectonic change in the industry (if it is not an illusion, of course!) might make it all irrelevant. Well, the approaches I use still can be rebranded to being token-efficient to flourish in LLM era… But for now, I feel an irrational aversion for this angle.

For the time being, I stick to my “craft.” And still will try to write about it – about the ways of thinking in code that make me productive, and about languages, tools, and approaches that adhere to these ways. And I still hope to have an audience for that, and to find my place in the ever-changing industry.

I’ll probably stick to deeper, not wider topics in my upcoming texts (if any will come); focus on sharing pragmatic parts of my experience rather than philosophical outlooks on the general matters of programming. Though, TBH, I have one almost-finished “philosophical” text that’d marinated in my drafts since late summer… So maybe I’ll finish it some time in the coming weeks.

But after that, I hope to dedicate some efforts to writing about my approaches to testing and various nuances of experience I gathered by working on test suits of several large produces (including developing and publishing my own test helpers library).

So, till the next time. Hopefully, it will be soon.

And please support Ukraine.