As I’m sure the three people excited for the next installment of my Speedrunning College series have noticed, I’ve been radio silent for the better part of the past month. Silence can mean a lot of things in online projects, but it’s rarely a good sign. I could defend myself here by pointing out that I did complete a fascinating database course in my first week of silence, and I really do have all sorts of fun things to say about that the second I get around to it. And that’s true. But the reality is, I’ve certainly slowed down from my breakneck starting pace, and this series will be of no use whatever if I just glaze over all the causes of that slowdown and act like everything is going smoothly. In the same spirit of openness and bluntness I’m aiming for throughout this project, I’d like to examine just how this sort of project can grind to a (relative) halt.

Yep, it’s time to talk about rabbit holes.

Before I really dive in, I should make something clear about myself. Even though I’ve spent untold hours of my life on the computer, I’ve always been a dabbler. I’m not a self-taught programming wizard who’s been writing assembly from age ten. I’ve never modified a game’s code for fun, or taken a machine apart and put it back together. Raspberry Pis and Arduinos scare me. Yes, I took programming courses before, and yes, I’ve wrestled and googled my way through some thorny problems and fiddled with virtual machines and Linux here and there, but never in any lasting way. This is embarrassing for me, since the tech crowd’s always been My People. People around me have always been competent and curious and adept around all things tech. Me? I’ve had enough exposure that I certainly should be decent, but instead I grinned and nodded and posed my way through my way through in the rare times I actually did something more technical than visiting reddit.

But I’m not going to dabble my way through a course like this, which means I’ve been biting a lot of bullets and taking things a lot more seriously. I likely won’t ever be a Night Watchman, but I can do something. So when I realized it was finally time to replace my six-year-old laptop, the second computer I’ve ever owned, I resolved to build a PC for the first time and go from there. What follows is the story of what “going from there” looks like, step by gruesome step, as I passed through a gauntlet of tasks utterly trivial to any self-respecting hacker and thoroughly intimidating to the rest of us.

A simpler explanation of the goal, for those in the same boat as me

Speaking of which: threading the needle between keeping things technical enough for the self-respecting hackers to properly follow my mistakes while allowing the rest of us to follow anything is always going to be tricky, so anticipate a pleasant kludge of technical and non-technical explanations. There will be software gore and plenty of second-hand embarrassment. You may, too, notice it stretching a bit long. That’s deliberate. Every time I read about all this stuff, people say something that sounds like a simple one-step process but turns out to be a minefield that takes newbies twelve hours, so I want to point the minefield out. Skim if it gets to be a bit much.

Oh, and since I did say I was going to be honest: I’d love to say these problems are what took me three weeks, but that would be a bald-faced lie. Go ahead and imagine a ratio of something like four hours kicking around idly on the internet for every hour I worked on the rest of all this. Ever-scattered, I explored many more rabbit holes than just the technical ones as I waited for that critical mass of guilt and boredom to kick me back over into productivity.

Building a PC, all by myself

Building a PC was the first rabbit hole, since up until my Intro to IT class last month I didn’t actually know what a motherboard looked like or where the various bits attached. Since names like “AMD Ryzen 7 2700X” and “RTX 2070” were only so much noise, I did what any enterprising student would do and asked strangers and friends to build a pc for me. After the internet provided an initial build, my ever-patient friends explained to me that the extra $20 for “RGB” on RAM was just color, which I didn’t care about; that despite what I’d heard before, AMD was cool now; and that yes, not all solid state drives are created equal. Armed with new troves of knowledge, I blindly followed all recommendations, sat back, and waited for my new prize to arrive.

Everyone assured me that building it was pretty straightforward, so I tossed on a YouTube video and got the install started around 11 one night. Panic first struck as I held a $300 CPU over a spot I was assured it fit, continued as I shakily pressed a heat sink fan onto it and hoped desperately it had attached right, and continued to grip me with every expensive piece I grabbed and every screw I destroyed the threading on. The second-to-worst part was looking at rows of pristine pins, then jamming connector after connector into them and crossing my fingers that every cable was attaching properly and no pin was bending. The worst part, though, was the hard drive. Nobody told me, see, that it attached to the motherboard. There I was with this $150 rectangle small enough to swallow, looking for somewhere in my case to mount it.

A highly technical guide

I would have kept looking if my long-suffering friend hadn’t taken pity and circled the useful spot on my motherboard. From there, I started by sort of timidly resting the SSD on top of the spot, thinking “no, that can’t be right,” watching a few YouTube videos for guidance, and wincing as I jammed it in nice and tight.

Somehow or another, though, progress did come, and finally I sorted through a mess of cables, tried and failed to connect to my monitor with one, and settled on a nice familiar HDMI cable. Connect to motherboard…? Nope, try the graphics card. Success. My TV even worked as a monitor, to my delight and mild surprise. My CPU fan surprised me by glowing in rainbow colors when I turned it on, and my PC surprised me by flashing through a quick screen and then telling me it had no operating system to load. Don’t worry, I’m not so careless as to think an OS would come pre-installed — I’m just careless enough to have assumed it would take me somewhere to automatically arrange things. Cue another moment of crawling to my saintly friend for help, and a reminder that nothing was broken and if I spammed delete or f12 or something on that quick image screen things would work out. Once again, he provided some nice pictures to reassure me. Once again, things worked out.

Linux. I would first install Linux on my computer and get properly used to it. Back to my friend: Mint, which I had dipped my toes into before? Ubuntu? OpenSUSE? Debian? The mysterious Arch Linux, which my friend used and which brought to mind images of arch-liches and of rugged hackers compiling through the wilderness? Sense won out over ambition, and I settled on the safe ground of Ubuntu. Install went smoothly, connecting to a network went… ah, no network. No WiFi was detected? Faced with such an obstacle, memories of every little frustration and unfamiliarity with Linux rushed back to me, and even the color scheme seemed suddenly unbearably ugly, so I wiped the drive and tried again with Mint. Same result, so I threw my hands up in frustration and went crawling back to Windows via a free student key.

That’s when I finally found out that not every motherboard has a WiFi adapter built in.

Look, I did warn you of my ineptitude.

I happened to have one nearby, though, so once I realized the problem and found myself back in the familiar territory of Windows it was finally smooth sailing. Yes, that smooth sailing did involve my TV abruptly changing resolution and losing all semblance of image quality as soon as I got my other monitor plugged in, not to mention buying a couple cables I didn’t need before getting a useful one. Those worked out after a few Google searches, though. And yes, it did involve needing to get a WiFi extender when my roommate moved the router downstairs. There, though, I delighted in both its ease of use as a mass-targeted product and in my newly acquired understanding of its vocabulary from an earlier course (802.11ac! AC2200! WPA2! MU-MIMO! All no longer quite so mysterious). And sure, up through today I still haven’t managed to change that fan from its rainbow glow. Familiar, safe problems, all of them. In the end, for all my panic and my mistakes… the building process was pretty straightforward, and I got a shiny new PC out of it! For a few precious moments, I felt the afterglow of a successful project and realized just why people fiddle with all this computer nonsense.

Then I finished my database course and found an unassuming course labeled “Operating Systems for Programmers” behind it.

Re-reintroduction to Linux

The first thing I noticed about “Operating Systems for Programmers” was that the entire pre-assessment was full of intense-sounding technical details I had less than no clue about.

The second thing I noticed was that I would need to install Linux after all, this time on a virtual machine.

The textbook

The third thing I noticed was that the textbook was some 760 pages long instead of 200-some like my previous texts, and was presented in a convoluted-feeling way.

The fourth and fifth things I noticed were the dinosaurs on the textbook cover, so that was encouraging, at least.

Anyway, after some downright pleasant jaunts with HTML and SQL in my first couple classes, I was suddenly face-to-face with a dense, technical course full of all the details about OSes I never realized I didn’t want to know: processes and threads and remote procedure calls and dust and grime.

This section is not about that course. I’m still rolling around in the muck of it, absorbing what information I can and running away to Do Really Anything Else at every possible moment. No, this section is about one specific part of that course: writing my first real program in the last three years. See, the course as run by my university focuses on concept knowledge via a multiple choice test, but the textbook had some Highly Encouraged programming exercises and I felt weird and silly not remembering how to do any of them, so I resolved to do What It Took to at least start poking around the code. This was, well, a bit intimidating. I could squint my way through the example code, sure, remembering pretty quickly that * before a C variable indicated a pointer, finding what the & before another variable meant after some frantic Googling, mostly-but-not-completely following the logic after a bit more Googling for good measure. Writing my own, though?

I had never before written a single line of code either in C or in Linux. I hadn’t the faintest recollection where I ought to write it, how to compile it, how to do really anything useful. This all sounds trivial to any programmers reading this, but when you’re at the bottom looking up, it’s easy to come face-to-face with a dozen separate learning curves at once, where even “trivial” quickly spirals in startling directions. It’s both encouraging and discouraging, as well, to wander through Google for help: yes, every answer is available, but everyone answering seems to be a grizzled wizard with encyclopedic knowledge of the arcane arts, dispensing hints about the common and the obscure, dark rituals painstakingly acquired through centuries of experience with everything.

Okay, that might be an exaggeration, but it’s hard not to feel a little inferior.

My task, half assigned and half self-chosen: install a hypervisor, put a Linux distro of my choice on it, remember how to use the terminal, then figure out where and how to write code, compile it, and commit it to Github.

From the top, then. My course recommended using the hypervisor VMWare and tossing a virtual Linux distro onto it. That’s the first task. Just getting Linux running. Should be simple, yes? Just use VMWare and the copy of Linux Mint I had previously tried to set up, make a few button presses, realize it didn’t include Mint in its default options, and… ah, yes, there was one of the error messages I had so missed Googling. Something about not being compatible with “Credential Guard” in Windows 10. I poked around at a few suggested settings, couldn’t get it to work no matter what I did, and then vaguely remembered from my last course that Windows had a built-in one called Hyper-V. …which was greyed out in my settings, because ((more googling))… some setting I needed to enable in my BIOS.

Shut down. Poke around the BIOS. Find no setting. Google motherboard-specific information. Find a couple hints. Poke around BIOS again. No setting. Optimistically click a couple other settings. No dice. Check online again, finally realize I can search the BIOS for that setting, find the setting, and — success! Hyper-V was unlocked, and again I felt a momentary thrill of triumph that successfully coerced me into continuing. So I installed Ubuntu on it, watched it auto-configure because I was finally using a more common Linux distro, and confidently logged into my new virtual machine to find a pleasant callback to my previous experience installing Ubuntu: no wireless signal recognized. Googling and trawling settings within the hypervisor was frustrating enough that I deleted the whole thing and went back to VMWare one more time.

…and suddenly everything worked perfectly, and that thrill of satisfaction and successful wrestling came once more.

From there, I started trawling through the textbook, which you’ll remember is long and involved and not part of this story, so let’s skip ahead to the moment I decided to work through some of the programming examples in the book, since that’s when the deja vu really struck.

I’d been keeping it at bay, but the reality is I did intend to learn this all five years ago. All that stuff in previous courses about networks and databases was pleasantly new, but now that I had Linux installed and was playing around in the terminal, I remembered the times I’d used it before. I remembered, vaguely, some commands to navigate the filesystem, and typed in an experimental cd.. , ls , and then a host of other commands. I remembered hearing conversations about intimidating-sounding text editors like Vim and emacs, even using Vim for a bioinformatics course, remembered being satisfied with it because it used the same fun control scheme as the games I grew up playing, and remembered (to my childlike delight) that all I needed to do to install it was open the terminal and type in… what was it… vim and follow instructions provided from there.

What I had forgotten was just how different Vim’s interface is to, say, Notepad or Microsoft Word. With my emphasis on speed through my previous courses and to an extent through the textbook of this course, remembering I would have to reacquaint myself with an unusual (but, I was promised, blindingly efficient!) control scheme before even starting to code was sort of like running headlong into yet another brick wall. At least this brick wall, unlike the hypervisor nonsense, had an encouraging and cheery tutorial. And I was, I had to admit, learning and remembering some fun info, like the point that I could compile and run code written in Vim via only two or three lines of typing. No leaving the editor, no need even for the mouse. Another small thrill from that gave me the encouragement I needed to google around a bit and then actually write a simple “Hello world.”

My first C program

No errors! Everything worked! The terminal did gently remind me to sudo apt-get install gcc when I tried to compile C without downloading the compiler, but that too felt friendly and helpful. Time for the actual exercise, reading from one file and writing to another. Basic stuff, probably.

That’s when I remembered how programming actually works. Or, at least, how it worked for me as I tried to put a dozen half-remembered pieces together in one program..

Programming for Wannabe Script Kiddies

Every. Step. Of. The. Way. Is. Pain.

Just outputting a line of text is dead simple.

What about getting user input, since I needed the user to give me two filenames? A bit of Googling told me to use the command gets() , so I tried it only to have my compiler tell me it was dangerous, Google some more, and try fgets() instead. That was nice and seemed to work, so I thought I’d play around a bit (in basic, constrained ways) and actually output the results of both text strings in a sentence.

Some code snippets I tried, ideally situated to make programmers squirm. If you don’t program, just briefly imagine a dumpster fire and glaze right past these:

printf(“

You’re copying%s”,inputFile” to %s”,outputFile”.”)

and when that failed horribly,

printf(“

You’re copying”); puts (inputFile); printf(“ to “), puts (outputFile); printf(“.”);

which was an ugly kludge but sort of worked. It showed me that the puts() command inexplicably adds a newline after it, leading to this lovely outcome:

You’re copyinginputFile

to outputFile

.

My point isn’t to dwell on specifics trite to half of those reading and obnoxiously technical to the other half, but to illustrate just how quickly errors and unexpected interactions creep in for new learners or re-learners like me. Half the stuff breaks and you see it and remember why it’s obviously your fault, and then the other half breaks in ways you had no reason to anticipate, and each new line sends you scurrying back to Google with new error messages and search queries in tow. Break stuff, ask Google for duct tape, break the duct tape, patch the problems in your solution, repeat.

And then, after a while of 2am tinkering in this silly program, things suddenly just worked. Everything fell into place. The world was at peace. As with the moment after my computer was built, as with the moment I got the virtual machine running, I got this thrill of excitement and satisfaction. I did a program. It was mine, and I could fiddle with it and read and write files and handle at least a few errors and it worked.

Wait, though, came an unbidden thought. …don’t real programmers upload to github? And hey, don’t they work some command line wizardry to upload automatically? How hard can that be to learn at 2am? After all, I still had a github account, created those many years ago when I was going to learn everything, sitting optimistically with a grand total of 0 commits over half a decade.

Look, at this point it would be overkill to tell you about my ssh-key struggles. At this point, after hearing that I had to ask frantic questions about my hard drive for half an hour, panic about my BIOS because my boot screen was moving too quickly, and wrestle my hypervisor to the ground to get a ubuntu install going, not to mention every little struggle with Vim and C, you know exactly what happened when I tried to create a ssh key and link it to github. I don’t need to tell you about the half-dozen searches I did on variants of “github permission denied (publickey)” or “ssh agent has no identities”. You can already guess that I ran into problems creating the key, activating the key, copying the key, and understanding what the key even was. And it will surely come as no surprise whatsoever to learn that even after tossing a few hopeful lines about copying to clipboard into my Vim RC file, I couldn’t for the life of me figure out how to actually copy text from Vim to paste anywhere external. Retreating with my tail between my legs to LibreOffice, where a simple Ctrl+C and Ctrl+V worked as expected, was really almost inevitable.

After all that, though, here’s something else I hope comes as no surprise: In the end, with the clock marching resolutely towards 3am, I committed my first-ever lines to Github, uploading my first-ever Linux programs, written fully in C for my first time ever and in Vim for myfirst time in half a decade, from a Linux terminal inside a virtual machine I installed on the only computer I’ve ever built, over a WiFi network I had just extended, and marched one step closer to actually being able to create the tools I daydream about.

And yes, you could point out that I frantically deleted the code snippets from my pseudonymous GitHub account seconds after posting because I didn’t realize a shared commit would reference my real name, but that’s not the point.

Conclusion

In retrospect, most of what I did was pretty easy, or if it wasn’t it was because I was approaching things in rather the wrong order. But it felt like a rite of passage, in a way, diving down all of those rabbit holes and remembering the triumphs and frustrations of doing anything hands-on with computers. More importantly, it provided a pointed reminder of just how different theoretical learning is from practical, as assumptions are laid bare and simple steps expand abruptly into hour-long processes. I feel as if I am standing atop a vast construct of knowledge, poking my way around the edges. Doing things like this makes some of that knowledge feel real, at least.

My github is properly up (and public) now, and it will perhaps unwisely stay public as I complete my haphazard snippets of code this year. For the curious, I have also collected what I can of my search history through the second part of this project. You can view it here and watch the story unfold in a terse format. I remain on track to graduate within the year, though my pace has obviously slowed. Anki is still working its wonders, and the structure of this all has remained motivating enough that for the first time in my life I’ve stuck to my intended review schedule for a month and a half. I’ll be back soon with my analysis of my database course, at once the most compelling and useful course I’ve taken and the one with the most potential for improvement.

Until next time.

Throughout this project, I intend to continually experiment on the fly and provide regular updates analyzing my successes and failures in this game of learning. If you’d like to follow along or read my meandering thoughts on education, optimization, and whichever other topics catch my eye, you’re welcome to follow me here, on reddit, and maybe even on Twitter if I’m feeling particularly careless.