[Hammer and Linux] Episode 01. Why Writing Code Matters: Backup Hell and the Realization of Modularization

It has been exactly a year since I started studying Linux. I am 52 this year.

What got me started was a vague longing. The thought that "building something is cool," and the thrill I felt whenever a small piece of code I wrote actually ran was so fascinating and good.

Head-first crashes

My day job is sweating it out on construction sites. I started without even knowing the "L" of Linux, so I struggled a lot. At first the Korean input wasn't set up, so I cannot count how many times I wiped the system completely and reinstalled it.

On top of that, back when I started there were no excellent AIs around to help like now. So I studied by crashing head-first into everything. Of course, I am still a chick at this. (haha)

Coming home at 6 p.m. after hard work on site, washing up and eating, it was suddenly 8 p.m. From then I sat in front of the computer and studied one thing at a time. As it will be going forward, I went through an enormous number of trials and errors.

Worse still, I do not know English at all. I did not even know the word "school." With no other way, I repeated things endlessly until they stuck in my hands. Afraid of forgetting, I clung to them stubbornly so my fingers would remember.

First meeting with agents

Meanwhile, autonomous AI "agents" began to appear in the world. Before that I did not even know such a world existed, but from then on, building something became indescribably fun.

Just watching an agent take my instructions and hammer something together was enjoyable even if I only watched. Even though I wasn't typing it myself, it was fascinating to see it completed down to the smallest detail.

At first there were so many Linux commands and complex options that I could never memorize them. So I started by translating the man manual help into Korean, head-first. That took a really long time too. It probably took about a month of solid work.

When the translation was first finished I was truly happy. It was the first result of cracking the principles through head-first work.

Discovering free

The first AI agent I encountered was a place called "opencode." It had quite a few agents you could use for free. But being the free version, there was a daily usage limit. After an hour or two it stopped working. It seemed to check my IP address and block me.

Without getting discouraged, I turned on a VPN and tried connecting, just in case. And then, each time I changed country, the usage reset and I could use it again. To me it was a truly enormous discovery. It felt better than Columbus discovering the New World. (lol)

From then on I was so excited I pushed hard, sleeping only about 4 hours a night at most. My friends joked, "He's finally lost it," and "With that passion when he was young he'd have gone to Harvard."

Honestly, I briefly thought that even if not Harvard, I'd have made Seoul National University. The thrill I felt then cannot be put into words. It felt somehow like I was hacking a giant server and using it freely.

The local challenge and the 15,000-line nightmare

Then a thought crossed my mind. "Ah, instead of an open-source agent, what if I put a model directly on my local machine and build my own system?" Looking back, it was a truly innocent and reckless idea.

If someone told me now to do it again the same way, I could never. The code that piled up back then must have been over 15,000 lines. I can't remember every line, but the overall flow and "logic" are firmly in my head. I deleted and rebuilt so many times that getting just this one thing working probably took three months. At first it started at about 5,000 lines.

But from then on a fatal problem appeared. Change one feature of the code and the whole program would tangle up nicely and go dead.

Backup hell

That's right. Only then did I realize something important. Until then I thought that, like a smartphone app, downloading a program just installed a single file. But looking closely, I learned for the first time in my life that installing one program internally installs and interweaves countless related files. Since it wasn't my field, I'd had no interest, so it was only natural.

I wish I had known this structure from the start, but only after a bone-deep failure did I realize I had to split the code into pieces, that is, "modularize" it.

And from then on the real nightmare began. Whenever I changed one piece of code, I was anxious and kept backing up. If even one line went in wrong, the program would blow up or run in a completely different direction, which was scary.

Out of anxiety I copied backups everywhere. I stored them in about six different places, and because I backed up so much, a second problem erupted. I could not tell which was the real latest code and what was what. Saying "Is this it? Is that it?" in front of the monitor, I had a truly serious mental breakdown.