6 years

I’ve been writing code and messing with computers for around six years now. With 2020 around the corner, it’ll soon be seven. Six years of experience isn’t terribly much (at least in the software development world I think?), but I still wanted to take a moment to write down my thoughts on this whole experience so far.

I don’t really know what started my interest in programming or even computers in general–probably curiosity and stubbornness. My earliest experiences with computers were in front of a clunky Windows XP machine that my family owned. I was incredibly curious as I used it, and I was constantly asking myself questions like “How does an .exe file work?” and so on.

At this point, I spent most of time browsing C:\Windows and opening random programs. I would read the name of every .dll file I found, and open any .cfg, .txt, or .ini file I could see. I would browse Control Panel, looking for any hidden toggles and switches that did something cool. Looking back at it now, the intricacy of it all was probably what made me so invested. I wanted to figure out how it worked… somehow.

While this provided the groundwork for my later interests, it didn’t make me immediately start programming. I didn’t even know what programming was! Computers were very bewildering. I don’t exactly remember everything I was doing at the time, but I believe that I wrote a couple of weird batch files.

Here’s some odd things that I still remember thinking about back then:

• How are icons stored in .dll files? I remember finding loads of system icons whenever I went to edit a shortcut’s icon. The icon selector dialog box defaulted to a path pointing to a system DLL somewhere that contained all of the system icons. I couldn’t figure out how these were being stored at the time. (Probably as resources, maybe?)
• What is the Windows Script Host? Well, I didn’t know its name at the time. But I was a bit confused at the arcane error messages that would pop up whenever I double-clicked a .js file. I also noticed that the icon is similar to the one for .vbs files, just recolored.
• What does system32 mean? Why does it have much more files than C:\Windows?
• Why do I see a bunch of weird symbols when I open .exe files? What are they made of?

On one of my “adventures” I found IExpress, this Windows system program which would let you create self-extracting packages from a few files. I could now create .exe files! This blew my very young mind. I had opened it thinking it was some kind of strange shortcut to Internet Explorer (as the main executable to Internet Explorer is named iexplore.exe, which is kinda similar).

It goes on for a while. I enjoyed spending time exploring the hundreds of system files, uncovering parts of the system’s internals on my quest to figure out how the system cogs turned. It also fed my boredom pretty well. It’s weird how much of this I can vividly remember–my memory is really bad most of the time.

Now that I know too much about how computers tick, I guess you could say that the magic has gone away now. However, I still hold a vested interest in these things. They’re not entirely “magic” to me anymore, and I no longer feel enchanted by them, but I still enjoy spending hours upon hours making random programs that I’ll forget about in a few months. I still enjoy finding out how things work, and I like how accessible this kind of knowledge is. Today, answers are as far away as a simple search query on YouTube, Wikipedia, or your preferred search engine.

The enchanting feeling I used to get from computers has been replaced with an infatuation with the potential ability that these machines give you. Computers can run millions of computations per second. Writing my own programs felt like using an ultra powerful level editor that would let me do basically anything, molding a seemingly infinitely powerful machine into doing whatever I wanted. I could make a website, a chat bot, a social network, a game, a mod for someone else’s game–whatever.

Before I did some keyboard programming (y’know, the real stuff), I started out with this fun game on my 3DS called Petit Computer. It implements a dialect of BASIC named SmileBASIC, tailored specifically for the 3DS. One of the first programs I wrote asked you for your name and age and greeted you. I checked out all of the builtin programs and made sure to try to figure out their code. Some of the huge projects I embarked on were a text-based dungeon crawler and a basic shoot ‘em up game where you moved a spaceship around with the circle pad. I also made a jukebox program that could play the builtin BGM tracks, and a minimal paint program that would let you draw lines on the screen.

It took a while for me to figure out how to use it initially, but the BASIC syntax was basic for a reason. After several days of practice and reading the electronic instruction manual, wrestling the interpreter got easier and easier as I went on.

This is where my curiosity and creativity let loose. I could make basically anything I wanted. It’s like an infinitely powerful level editor, after all. I showed the dungeon crawler to my cousin and the shoot ‘em up to my brother. It was really enjoyable seeing them play the games and enjoy them, even if only a little.

I also spent some time checking out the Nintendo Life forums for QR codes of other people’s programs. I would scan them, play with them, then inspect their source code. This is where I adopted a lot of techniques for my own programs and games, and I learned a lot. I feel like a learning process like this is essential to learning how to program. It’s analogous to checking out other people’s software on GitHub to see how they did stuff (which I did too!). Learning by example is great, and I find myself taking that route a lot nowadays.

Over these past six years, I’ve been entirely self-taught. I’ve fantasized about taking a formal course in computer science many times. However, I feel that I’ve learned a great deal just from the internet and my own curiosity. The internet’s pretty amazing in that way. The internet isn’t as guided as a formal course, but I feel that the internet is a kind of “choose your own course”. Things are gonna take longer because you’re your own teacher, but it (sort of) eventually pays off.

You get to choose what you want to learn, and at what pace. If you hate something, you can just ditch it and start learning something else. If you don’t know what to learn, you can look around for stuff that might interest you. And there’s mountains of stuff out there for you to tinker around with.

What eventually led me to actual programming was making websites. I’m not sure what compelled me to learn web development, but I googled “how to make a website” one day, and I was greeted with this little website called w3schools. (If you want to learn web development today, use MDN–this is just what I found and used back then.)

HTML and CSS were easy enough, I thought. Make this <p> blue and this <span> bold. JavaScript was where things really picked up. According to w3, it allows me to add some interactivity to my webpages. That seemed cool enough, and I gave it a go.

I got the hang of basic syntax after a bit, but errors and bugs still mystified me. Things would just cryptically fail, and I had no way of knowing as I didn’t have a developer console. Back then, I was actually doing all of this on my iPod Touch. (Great, huh?) I was minimally aware of indentation, and things were a mess. I didn’t care though, because it worked, and that was what mattered after all!

If I got stuck on something, I googled it. Being able to google a question or a problem and find an answer is a skill, and I developed that skill during this time period. I eventually found Stack Overflow, and I would frequently consult and peruse it for knowledge. It got me really far.

I still remember struggling with functions a lot. At one point, I couldn’t figure how the hell parameters worked. I think a few of my hair follicles were torn out that day, funnily enough. When I finally figured it out though, it was incredible. I still tear my hair out today, only over bigger things now instead of parameters. It’s interesting how it seems that your problems never actually go away–they just change or manifest into other things.

With some webdev knowledge under my belt, I set off to learn “real programming”. I was a bit obsessed with writing to the filesystem–JavaScript can’t do that (…right?) I need to learn a real language! During this time period, I began to learn Java, Python, and C (roughly in chronological order there).

My memories are a bit fuzzy, but I still remember writing Android apps on my phone using this app named “AIDE”. I also started to mod Minecraft: Pocket Edition with this little app called BlockLauncher. It had ModPE, which let you write mods for the game in JavaScript. I quickly transferred my knowledge from the web to this scripting API, and I would end up spending hours on it. I would write hundreds of scripts, each only tens of lines long. (Some were decently long, but that was the average length.) I would write one to try out a function that seemed interesting or implement something I thought would be fun, then I would move onto the next. I would frequently consult the modpescript_dump.txt file at the root of /sdcard/ for inspiration. Alas, they’re all gone now, unfortunately. (Curse past me for not keeping proper backups.)

Something notable I remember creating with the “AIDE” app is an IRC bot engine which allowed the user to create their own IRC bot with JavaScript. Sound familiar? The IRC protocol is incredibly simple, though that didn’t stop me from using a dependency I found and hooking it up to Rhino to create something that I was really proud of at the time.

After a bit, I was finally gifted a computer from my parents. Now came Java (but on the desktop), Python, and C. I remember using Eclipse and NetBeans to write some weird programs. Nothing with too much substance, unfortunately. But I liked to write these random things that would take advantage of the standard library and such. These programs, too, are long gone to countless wipes from trying out Linux distributions.

C was a bit of a ride. I had only known higher level languages at this point, so pointers were a struggle. A real one. Today, they seem so simple to me now, but I wanted to tear out another patch of my hair back then. It’s kinda surreal to think about. I ended up sticking with Python because I found it more enjoyable, but C’s closeness to the hardware and performance still grabbed my attention occasionally.

I also remember being really unsatisfied with the programming languages I was using at the time. Nothing felt right–I spent a lot of time googling for obscure languages that would satisfy my needs, whatever they were. Nothing had the perfect syntax, the perfect keywords… I wasted an embarrassing amount of time trying to figure out what I liked. The concept of making my own language felt unreachable, so I couldn’t do that.

I was really adamant on finding a language like Python that would compile straight to those mysterious executable binaries. There was something satisfying about being able to just double-click the file, but I didn’t want to spend my time writing C. It’s funny looking back at it now–it’s such an unreasonable expectation to have a dynamically typed programming language compile to a binary like that. Tools such as pyinstaller didn’t satisfy me because it felt like cheating. Eventually though, this faded away without notice. I’ve gotten comfortable with the tools I know, and I continue to learn about things that seem interesting.

It was also at this time that I found out about Linux. Well, GNU/Linux, I guess. My first Linux distribution was Ubuntu 13.04 (Raring Ringtail). I still recall the thrill of watching the installer’s progress bar run across the screen as apt worked away, installing hundreds of packages. Eventually, I found Xubuntu and started to use that, finding the user interface more minimal and friendly. It performed well on my cheap laptop, too. After getting a bit bored, I tried out more distributions after finally settling on Arch Linux, which is what I would be using today if I didn’t switch to macOS. (Hey, I can see you judging me from here.)

Shortly after installing Ubuntu though, I got to familiarize myself with the terminal and the command line. I got to know bash, cd, rm, all that stuff. I also started learning git, started using Sublime Text, switched to vim, then neovim… can you see where this is going?

More recently, I’ve been making Discord bots, and I plan to learn about Scala, Rust, MLs, more about system administration, and networking. There’s probably also more stuff in the back of my mind that I can dig up later.

Something interesting when it comes to this whole programming thing is that you never stop learning. I know–it might seem obvious, but when you constantly lay things out like “Okay, I’ll learn this, then I’ll be done, and then I’ve succeeded” as I did, you come to see how things actually pan out. You don’t have to consciously think this, either. I think that’s what my mind just naturally did for itself.

I’m really used to setting things out as goals, despite me almost never fulfilling them. I can’t just learn something and be done with it. It’s a constant cycle of self-improvement. And it’s a long cycle. I remember almost tearing my hair out when something I wrote didn’t immediately work. That’s not how it goes. Perfection is an impossible goal.

I can’t really say for sure, but it seems like the feeling of disgust you get from looking at code that you wrote a few years ago will be around forever. As long as you keep on learning, the code you write now will always be better than the code you wrote back then, even if only by a little each time.

There’s still a ton of things I don’t know about, and I’m happy to continue endlessly dissecting them until I find something else to pursue… whatever that happens to be.