It probably started when I was very young.
My father worked in an industrial automation department that housed a Soviet counterpart of the IBM System/360-370. Sometimes he lifted me through a window into the computer room, and they let me play with a massive keyboard. I still remember it. To a child it felt like touching something mysterious, almost magic.
In high school I spent most evenings in my father’s office, and that’s where I first sat at an EC-1840, an IBM PC-compatible machine made in Minsk. At first I just played games. Before long I wanted to write programs myself. I still remember how that felt: you get access to a computer, the ordinary limits stop applying, and almost anything seems possible.

Image source: pikabu.ru
In ninth grade a friend told me about a nationwide student conference organized by MIPT (Moscow Institute of Physics and Technology). By then I had written a graphics editor in BASIC. I wrote extensive documentation for it, sent it in for review and got invited to Khimki. Looking back, I suspect the documentation impressed the organizers more than the code.
For a boy from provincial Bobruisk, a conference near Moscow was a big deal. My project got a high rating, and I received a scholarship from the Lenin Children’s Foundation.
I came home full of ideas. In tenth grade I wrote a primitive line-by-line Russian-English translator in Turbo Basic that worked in both directions. After submitting it to another conference I went further and rewrote it in C++, with a user interface in the style of Turbo Basic. By the standards of the time it looked quite impressive.

many of my earliest experiments with programming began.
Image source: www.dosdays.co.uk
At that conference the section chairman asked me to leave the new version with MIPT. I was promised payment and never saw any money. That was my first encounter with what I later learned is called a “gentleman’s agreement”. Did it put me off? Oddly, no. If anything, it made me even more interested in writing software.
Before university I was completely obsessed with programming. I kept feeling I was on the verge of discovering something important, that if I worked just a little harder I’d come up with an idea that would change the world. Even at military training camp, on night duty in the barracks, I spent hours writing code fragments and algorithm sketches on scraps of paper while everyone else slept. The big breakthrough never came, but I did find out what I wanted to do with my life.
At university I met Igor Kolupaev, a like-minded developer who became a friend. The Internet barely existed in Belarus then. Software and knowledge moved through FidoNet and, more often, from hand to hand.

FidoNet was how many of us exchanged software, ideas, and experience.
Image source: www.computerra.ru
One day we came up with the idea to collect the best software written by students at Minsk universities, package it as an electronic almanac and distribute it on 3.5-inch floppy disks. Some of it was genuinely impressive. One project, an alternative to Norton Commander, I kept using myself for years afterward.
We finished the first release but never got a distribution deal, and the project stopped there. Still, it was my first taste of what you get from sharing software and knowledge openly. In a way I was into open source before the term was widely known.
In 1998 I finally got Internet access. I learned Perl and started turning my ideas into personal web projects. The Belarusian Internet was still mostly empty, so even simple services found an audience quickly. One of mine was a banner competition: anyone could register and upload a banner design, and other users voted and left comments.
Around that time a few people who were building the Belarusian Internet formed an informal group in Minsk. There were about a dozen of us, and I was surprised to be invited. We met regularly, swapped ideas and argued about where the Internet was going and what the Belarusian web would look like in a few years.
The whole industry was like that back then, small and very active. There were tech parties, conferences, national competitions and endless experiments. As the Internet became a visible part of public life, TV programs started inviting people from the industry, and over the years I took part in a number of them. It may sound odd today, but almost everything we did was being done for the first time.

Image source: www.kozhuro.com
In 2000 I moved to Minsk for work. It was the era of web portals, and portals seemed like the answer to everything. We tried to build one ourselves without really understanding what problem it was supposed to solve. Unsurprisingly, nothing came of it.
What did come out of that period was an idea for an electronic publishing platform. I brought it to Atlas, where I developed MySite CMS, at a time when hardly anyone in Belarus used the term CMS.

A few years later I joined Red Graphic and built Site Sapiens CMS and XML Sapiens ML. I still think Site Sapiens was ahead of most local competitors, especially with its tree-based content structure. Back then, though, I cared far more about adding features than about architecture or maintainability.

It took me a while to see how much maintainability matters. Getting code to work is the easier half. Keeping it maintainable and extendable years later is much harder, and that’s what eventually got me to study software architecture and engineering practices seriously.
Ironically, my long-standing fascination with CMS platforms is what brought me to Crytek. The company was putting together a team for a new web project and thought my CMS experience would be useful.
When I moved to Frankfurt in 2009, PHP was still my main language and I was skeptical about JavaScript. Most people saw it as a browser scripting language, and prototype-based OOP felt strange and unfamiliar to me.
But the web was changing fast. Client-side applications got more and more sophisticated, and Node.js, released that same year, made server-side JavaScript practical. That’s when I started taking the language seriously.
Eventually I realized I had been exactly the kind of developer Douglas Crockford describes in JavaScript: The World’s Most Misunderstood Programming Language. JavaScript before ES6 did have real shortcomings, though. Libraries like jQuery existed for a reason, they helped developers work around a lot of the language’s rough edges.
What bothered me most was the lack of familiar object-oriented syntax. One of my earliest GitHub projects, xObject, was an attempt to make object-oriented programming in JavaScript feel more natural.
ES6 (2015) changed the language a lot. It became more expressive and much nicer to work with. Even before that, the platform around it had given us WebSocket, Server-Sent Events and WebRTC, and later came Service Workers, the Push API, async/await and plenty more.
Over the years JavaScript grew from a browser scripting language into something that runs almost anywhere: servers, desktops, mobile devices, automation systems, even game development.
I came to frontend frameworks fairly late. At Crytek I was once given a small desktop application built with NW.js, and a colleague asked me: “Why do you keep writing everything in vanilla JavaScript instead of using a framework?” Back then I cared a lot about how much code an application had to load before it became usable. I had just finished jsic and was pleased I had at least split my code into logical modules.
The question was fair, though. As applications grew, maintaining them got harder and harder. Of the frameworks around at the time I picked Backbone. It was lightweight, stayed out of the way and matched how I think. That choice led to several experiments, ng-backbone among them.
Then, in 2013, React arrived. Together with server-side rendering, hydration and Node.js frameworks like Express and Koa, it made PHP unnecessary for many of the projects I worked on.
I had worked with PHP for decades and never fully made peace with its inconsistencies. strpos() takes the haystack first and the needle second, in_array() the other way around. The language often felt like it had grown organically, without a coherent design behind it.
Even so, a hand-assembled React and Express stack always felt unfinished. Responsive images needed separate solutions. LQIP (low-quality image placeholders) was mostly DIY. Every project meant putting the same set of independent tools together again.
The first platform that felt complete to me was Next.js 15. Problems I had spent years solving by hand were finally built into the framework.
Looking back, I got into the industry just as web development was turning into a profession. Now there’s another big shift, with more and more work handed over to AI systems. Sometimes it feels like I’ve lived through the industry’s whole lifecycle.
In the 1990s I wrote assembly routines to draw pseudo-graphical interfaces and animated starfield backgrounds for Clarion applications. In the 2000s we built drag-and-drop interfaces in JavaScript, a language many people still called a toy. In the 2010s I made a no-code test automation tool, an Electron desktop app that installed NPM dependencies on the fly and ran Jest tests inside.
Each of those shifts made us drop old assumptions and learn things that had looked impossible a few years earlier. AI is the next one, and I already hand a fair share of routine work to Claude Code. Whether it ends up like Node.js or like the portal craze of 2000, I can’t tell yet. We’ll see.