What's this?
Of all the different sections of this site, this is the first one that I came up with. I wanted a place where I could tell the story of how I got into this computer thingy.
Not that it's super interesting, most probably it's pretty stereotypical. But this is precisely why I think many of you around the same age will discover parallels and stuff that resonates with you.
In a day and age, when everyone becomes “passionate” about IT overnight, programming is not about hacking anymore, but producing shareholder value, and god forbid, even the sole act of writing code is questioned as it's rumored to be one of the first crafts to be taken over by AI (I promise, I won't mention AI again in this article), you can hardly see the sun over the clouds. And this is exactly why I wanted to share my story: an ode to the joy of writing code.
Now, without further ado, let's take that trip down memory lane!
It's the late 90s. My Dad, an attorney, bought a personal computer to do his work at home. I don't remember the exact specs of this machine, but you can be sure it had no internet connection (not even dial-up!), and was running Windows 3.1.
While the computer was primarily used for my Dad's work, it also served as the family computer. We played games on it together, and that's right where my earliest computer-related memory originates: playing SkyRoads.
Now, there's no shame in not knowing SkyRoads. I didn't recall its name either, as I only had a vague memory of “jumping with a spaceship between platforms” (yup, that's how I looked it up on Google, and found it on Reddit).
As time went on, the family machine got upgraded. We installed Windows 98 and then Windows XP shortly after. I still remember the day we got Windows XP, and first listened to Highway Blues (on one of those clunky beige speakers, of course). Keep in mind, still no internet connection!
Of course, it was not just the OS that changed; we also got new games: GTA 2, Age of Empires 2, and Heroes of Might and Magic III, to name a few of my favorites.
Core memories around this time include asking my grandpa what “population limit reached” meant in AoE2 (the game was in English, and 8-year-old me barely knew a few words), and playing fierce battles with my sister in Heroes III.
A recurring theme in this section is how we played together on the family computer: either with my Dad or my sister. To this day, I rarely enjoy playing solo but find true joy in playing with (or against) others.
Comenius Logo
I have to admit, even true programming OGs might not recognize what's in the first picture: a distribution of the Logo programming language, called Comenius Logo.
Comenius Logo (or comlogo, for short), with its cute little turtle, was my first experience with coding. The main idea of comlogo is relatively straightforward to understand, even for a 10-year-old. You control a turtle and draw using instructions such as FORWARD 10 (which moves the turtle forward with 10 pixels) or RIGHT 90 (which turns the turtle 90 degrees to the right). The language even featured loops in the form of REPEAT 4 [ instructions ].
Since comlogo offers a visual programming environment, it looks exciting enough to capture kids' attention. However, even though I remember drawing some scenes and even some fractal-like structures, I wouldn't say this was the one that got me on the path.
Free Pascal
While comlogo is a niche for sure, Free Pascal is, by all means, a mainstream environment.
But how did I get in touch with Free Pascal?
Well, unbeknownst to her, it was my sister who got me hooked on this programming thing by showing me her homework. It was a program that computed the hypotenuse according to the Pythagorean theorem.
Sure, you could draw fancy things with that turtle, but doing maths was something else. Comenius Logo seemed more like a toy, a gimmick at this point. Free Pascal, on the other hand, with its blue-ish background, syntax highlighting, and serious instructions (just compare UP 10 with WriteLn("Hello")), felt like magic.
I immediately signed up for a programming class in my school that started at 7 AM (the so-called zeroth class). Of course, at the time, I didn't know that I wanted to do this for a living; it was just the pure curiosity of a 12-year-old (or something along those lines).
PASzamolo and my first machine
My first "serious" program was an iteration of the hypotenuse computation. It was called PASzamolo (from Pascal and "számoló", a Hungarian word for a calculator), and it was a multi-purpose calculator program. Apart from the standard features of addition and multiplication, it also included somewhat wonky ones, such as saving the results to floppy disks and changing the menu theme.
While Microsoft deserves all the blame for its recent actions, one must give credit to its unparalleled backward-compatibility guarantees (you can read one such story here). As a result, you don't need Windows XP to run PASzamolo; it runs just fine in Windows 11's command line. Just get it from SourceForge.
After seeing my growing interest in programming, my parents got me my first computer, which, for the time, was somewhat surprising: an HP OmniBook XE3 notebook, not a desktop. It was a second-hand machine that my Mom initially used.
Counter-Strike 1.6
What does CS 1.6 have to do with my first programs? Well, it's not necessarily CS 1.6 per se, but AMX Mod X. Let's jump in!
Even though we were well past Counter-Strike: Source's release date, gaming in my first two years of high school meant playing CS 1.6. I think we can attribute this to its modest system requirements and general availability through semilegal and pirate channels. Even with a potato computer and no money for games, one could play CS 1.6.
With friends, we had our dedicated server, called "Mindenki Játszótere" (Hungarian for "Everyone's Playground").
I know, I know, cool story, boomer, but let's get back to programming. Now, if you played CS 1.6, you might remember round sounds: short audio cues signaling the end of a round. Every server needed its own set of these to stand out from the crowd. As such, joining a new server might have taken as long as 20 minutes (or more, if the server didn't have FastDL enabled) to download these MP3 files.
Jumping on the round sound bandwagon, our server also needed those. However, you couldn't just add them to a vanilla CS 1.6 server. You had to get your hands dirty and install some AMX Mod X plugins.
AMX Mod X was some sort of a host environment that could run plugins written in the Pawn embedded programming language. Pawn, in turn, is a C-like scripting language with functions, loops, conditionals, so everything you'd want from a general-purpose programming language, except for one thing: structs. Yeah, it lacked structs.
In any case, I wrote several AMX Mod X plugins, most notably our custom round sound plugin. Its differentiating feature was its ID3 tag-based loader: you just selected a directory, and the plugin automatically read the artist-title info from the contained MP3 files. Other plugins at the time needed a separate config file for this metadata.
readID3(strFileName[], strSong[31], strArtist[31], strComment[29]){ new hwnd;
hwnd = fopen(strFileName, "rb");fseek(hwnd, filesize(strFileName) - 128, SEEK_SET);
new i = 0;new j = 0;new tag[4];
while (i < 3){ tag[j++] = fgetc(hwnd) i++;}
//vagy nincs ID3, vagy ID3v2if (!equali("TAG", tag)){ i = 0; j = 0; fseek(hwnd, 0, SEEK_SET); while (i < 3) { tag[j++] = fgetc(hwnd) i++; }
//Nincs ID3 if (!equali("ID3", tag)) { formatex(strArtist, 30, "%L", LANG_SERVER, "UNKNOWN_ARTIST"); formatex(strSong, 30, "%L", LANG_SERVER, "UNKNOWN_SONG"); formatex(strComment, 30, "OTHER"); return -1; }
readv2Header(hwnd, strSong, strArtist, strComment); fclose(hwnd);
return 0;}
j = 0;
while (i < 128){ if (i >= 3 && i < 33) { strSong[j++] = fgetc(hwnd); } if (i >= 33 && i < 63) { if (i == 33) { j = 0;} strArtist[j++] = fgetc(hwnd); } if (i >= 100 && i < 128) { if (i == 100) { j = 0;} strComment[j++] = fgetc(hwnd); }
i++;}
formatex(strComment, 30, "OTHER");
log_amx(strComment);
fclose(hwnd);
return 0;}The above code sample reeks of every imaginable code smell. Ugly formatting? Check! Terrible variable names? For sure! Multiple levels of abstraction in the same function? You guessed it: yup!
Despite all of those issues, there's still something admirable about this piece of code. It's as direct as it gets: there's nothing fancy, just a raw approach to solving the problem at hand. Nowadays, when everything feels more complicated than it should be, it's like a breath of fresh air to look at such an innocent style of coding.
Looking back, this was one of the pivotal moments. It was at this point that one of my programs became widely used, even if only indirectly. Through coding, I put together something valuable for others. On top of that, I had tons of fun writing it. Something started to click.
Turbo Delphi and the GUI
I'm pretty sure that those who know Free Pascal were asking themselves: if you started with Pascal, where's Delphi? Don't worry, here it is!
But first, for those who don't know Delphi, let me get you up to speed. Right off the bat: at its peak, Delphi was the single best programming environment ever! Architected by Anders Hejlsberg (the same guy who brought us TypeScript), the Delphi environment featured a visual editor, an interactive debugger, and even source code control. Its drag-and-drop editor, paired with the Visual Component Library (VCL), made it effortless to build Win32 GUI programs. Apps written in its most popular edition, Delphi 7, are still in use today (at least in Hungary).
Now that we're on the same page, let's get back to the main storyline. In an effort to make the otherwise proprietary Delphi ecosystem more approachable, CodeGear published Turbo Delphi Explorer, a free edition. Somehow, I got my hands on one of these CDs (maybe it was an attachment to the CHIP magazine?), and it blew me away immediately.
For the first time, the apps I developed had the exact same user interface as the native ones on the OS. And these interfaces were super intuitive to build, too! I just selected the appropriate components from the palette, organized them on a window, set up a few event handlers, and boom, I had a rather serious-looking application. It's tough to convey how revolutionary this felt: like going from walking to flying. Gone were the days of tinkering with the terminal (or plugin scripts); it was rapid application development time, baby!
At the time, as you might expect, I had no idea of either coding standards or business value. I just wanted to have fun and write cool apps. None of the antipatterns, code smells, accessibility issues, or performance problems mattered partly because I didn't know what they were, and partly because the sheer joy of coding dwarfed them.
Having fun with Turbo Delphi marks the end of the first chapter in my programming journey.
It marked the end, as by this time I already realized I wanted to be a software engineer, so I started looking more into the craft: buying books, participating in competitions, and applying to computer science uni programmes. The simple days were over, and another chapter had begun.
Nowadays, when I'm writing code, it's not as simple as it used to be. Linters and formatters. Error handling. Logging. Security. Database schema. Type safety. Coding standards. Accessibility. Performance. GoF patterns. Frontend. Backend. The most recent JS frameworks. Vulnerabilities. All of these and more are always at the back of my mind, whether I'm just cobbling together a one-off script or architecting an entire application backend.
There is one thing, though, that remains from the early days: the joy of coding. The joy of creating something from nothing through casting spells in the form of code.
When I'm happy, I write code. When I'm down, again, I write code. And in between, I write code, too. It's like a warm coat over my soul that's always there to put on.
Programming has been with me for the majority of my life. And so far, it seems it'll stick for the rest.