For the last year or so, I’ve been getting more and more curious about trying Linux. Historically, I’ve been relatively open to the software and overall tech configurations I run as my “daily drivers.” The brands and operating systems of my various cellphones have been a great example of this: my first phone was an iPhone 5, then a Samsung Galaxy S6, I think I had two Google Pixels after that, and my last couple of devices were both iPhones. Gaming has been similar — my folks got my brothers and I both a PS3 and an Xbox 360 when those were out, then I got an Xbox One and later traded that for a PS4 in middle school before building the PC I currently have (though, I’ve upgraded every single part of that aside from some of the original storage).

This is all to say I’m about as agnostic to tech brands as a person can be. This has been tremendously helpful for me, and here’s why I think so: most people born in or after the 1990’s have a fairly curated, controlled and insular experience with the technology they use on a daily basis. Most of my peers, as far as I know, got an iPhone at some point in middle or high school and, as a result, they’ve almost completely dedicated their online lives to be within the Apple ecosystem. I always hate it when people start talking like this on places like Reddit as though these people are too stupid or blind to liberate themselves from the clutches of the post-1984-ad-campaign Apple, so I’ll make it clear that I don’t think my approach is necessarily “better.” I think it is better for me. For people who value the admittedly seamless experience of having a bunch of products that are essentially always talking to each other to coordinate the best user experience for you (and it honestly is incredible when you have multiple Apple products), coupling an iPhone or Samsung Galaxy with a laptop, your watch, and their proprietary headphones and tablets is the type of user experience it seems like we were promised and was actually delivered.

Old School

I think the timeline is important here because it’s easy to forget that computing was a niche and dense hobby back in the day. If you owned and regularly operated a computer before, say, 2000, you would have to know much more about the machine and how it works than you do today. The first home computers — the Altair 8800 and Apple 1 — were basically just boxes of parts that you would have to solder together and assemble. With the Altair, you would be programming the thing yourself by toggling switches on the main board. Even well into the 1990’s, most IBM systems would boot you into MS-DOS that you’d have to navigate manually with commands and type in the full path in order to get a simple program to run. The early versions of Windows made things more usable with dedicated program managers and graphical interfaces, but it really wasn’t until Windows 95 or 98 (or XP, depending on who you ask) that things started taking the shape they do today. This was also the era that a Finnish dude released what was basically a free version of Unix (technically of GNU). And remember, there was practically no internet until the very end of this rough timeline, so everything you did needed to come from physical media you would get from a store or mail-order package, word-of-mouth, or trial and error with a hope that you wouldn’t brick your whole machine. This is not what most people would consider “fun” or even “interesting”.

Layers of Abstraction

So, a computer is basically just a device which performs a series of instructions automatically according to some program. If you type a key on a keyboard, it sends an electrical signal through a series of what I’ll just call ‘nodes’ (things like the motherboard, RAM, etc. — that is, parts that the signal must pass through in order to get to the end-point) to the thing we really care about at this point, the CPU, which interprets this electrical signal, which takes the form of a series of on/off switches, and the CPU takes those on/off switches and performs some command. So, if I type the letter ‘k’, that is a series of on/off switches, the CPU then takes those and “writes ‘k’” based on that. The precise details aren’t that important here, the important thing is that everything a computer does could technically be done by taking a giant switchboard with millions of light switches and manually flipping them on and off. In fact, that’s essentially what some of the earliest computers were, and the Altair 8800 was just a really small one of these. But, nobody wants to do that shit. So, since the core parts of computers are, most simply, “things that can do math” and math can be thought of as basically “just a bunch of formulas”, that enables us to create continuously operating systems that act as a layer of abstraction away from the physical architecture of the hardware but still allow you to control the hardware. So, you type something in, that writes a little math formula that tells the CPU to flip a bunch of switches, and now you’ve “done something” with the computer. So, instead of manually switching things on and off, you have this operating system that just does that when you tell it to. Most operating systems also allow you to run other programs on them, so instead of the pre-defined operations the OS can do, you can have this other little package that also does this other thing, which we call applications. This is why you typically have to download a different version of an application depending on what OS you’re running — the thing that sits between that application and the physical hardware is different, so the application also needs to be tweaked a bit to be interpretable by the OS and, therefore, the hardware.

You can think about it like this: I can probably make thoughts happen in your brain by stimulating individual neurons or sets of neurons in specific sequences in order for you to imagine, say, the thing I ate for breakfast today. But, nobody wants to (or in our case literally nobody really knows how to) do that shit. So, I’ll use this language system to kinda make the thoughts happen on their own. This is a kind of really bad analogy for a lot of reasons, but in terms of “layers of abstraction” and interpretability, it works for now — the neurons are a type of hardware that are way too numerous and complicated to individually manipulate for practical purposes, so we run language as a type of software that manipulates large sets of the hardware in somewhat predictable ways.

Up to this point, what I’ve mostly been describing is actually the kernel. A kernel is a part of the operating system that has full control over the computer’s hardware. It is always present in the computer’s memory, there are always processes of it that are running, and it essentially does all the coordinating between all the hardware and software components. For our grossly misrepresentative brain analogy above, we might think of the kernel as cognition generally: it’s an abstract system that organizes, coordinates, and optimizes all the probably thousands or sometimes millions of things happening in the entire system at any given moment. When you boot up your computer, the first thing that loads from the bootloader is likely the kernel.

The next old thing

This finally brings me to Linux. There are a ton of different Linux “distributions” (you can basically think of them as ‘flavors’, ‘versions’ or ‘configurations’ of the same basic kernel) but, for the most part, there are three major families that the bulk of unique flavors are based on: Debian, Arch, and RPM. I won’t go into too much detail about them, but I will say that part of the reason there are so many (I think in the neighborhood of 600 distros) might go back to the original design philosophy of Unix — that being very modular — and GNU is heavily inspired by Unix (however, it literally stands for “GNU, not Unix”), and the fact that it’s open source.

About a year ago I downloaded Debian on my main desktop and dual-booted for a few months. At some point, however, the SSD I booted Debian from died and I haven’t been able to (or really got around to) recover it. At that point, I had been mainly booting Windows anyway, so it wasn’t much of a loss. Then, I had an idea that was unrelated: I wanted to get a cheap mini PC to dedicate to school and work because I’m notoriously bad at separating those two things from everything else when they’re on the same system. I also wanted to expand my personal compute a little bit, which has since grown into a whole homelabbing thing for me. So, I found one on Amazon and also nabbed the cheapest 1TB M.2 SSD I could find to dual boot from Linux on there. This time around, I chose Arch instead — the reasoning being that Arch gives you the kernel and the basic Arch things (historically, it was a 500 MB install, but in the last few years it grew to about 1.5 GB), and I figured if I wanted to actually learn Linux, I should go with the most do-it-yourself build I reasonably could (there is a more dedicated DIY Linux distro, but I ain’t doing allat).

Recall

Fast forward to about a week ago and I came across a piece of news from about a year ago I had missed. Microsoft piloted a feature called Recall, which is a Copilot feature that gathers data on your activity, primarily by taking screenshots of your device. This is an opt-in feature that is really only available on select PCs that have the necessary hardware and Windows 11 installs. There was a ton of backlash at the time of announcement and they have reportedly since taken steps to secure it before they rolled it out. For example, Recall can filter for sensitive info like credit card numbers or passwords, the data is stored locally, and, again, you have to opt in to use this feature. However, this still concerns me, and here’s why.

You Don’t Own Your PC

I don’t exactly know when things pivoted this way, but there is a clear trend in tech that is distinctly anti-ownership. Really, this probably goes back to the 90’s with the whole DivX thing. When you purchase a Windows PC, or Windows 11 itself, for example, you are licensing the property from Microsoft. A license agreement, by definition, is an agreement in which the licensee is allowed to use the intellectual property of another party without transferring ownership. For example, if I’m producing a movie and I want to use a song from a popular music artist, I can engage in an agreement where I use their song in my movie but I don’t subsume the ownership of their song. Then, some portion of my earnings go to them, if I publish a soundtrack of the movie, then some of that money goes to them, and so on and so forth. I use this as an example because I think licensing is a very good thing in use-cases like this — crucially because it maintains the ownership rights of the artist who should have them. I think this kind of licensure is good.

There’s a difference here. Remember how I said that the kernel “has full control over the computer’s hardware”? That is meant quite literally: the kernel is the thing that holds the keys to all your files, every single process that happens in your computer (aside from maybe a few pre-boot firmware processes) does it via the kernel, and it controls as close to everything about what your computer does, when, and how as something can. To me, there’s nothing wrong with having an AI system be able to access kernel-level or hardware-level things on one’s computer by itself (not that Copilot is really doing this, as far as we know). Additionally, for most practical purposes, it makes close to zero difference if you technically own the specific kernel instance running on your machine or not. The important thing for a personal computer is that it works, it’s reasonably secure, and you don’t really have to worry about it beyond an occasional upgrade or something like that. Unless you’re doing something illegal, you shouldn’t really care about whether or not it’s yours.

But the United States also has a Fourth and Fifth Amendment for a reason. There are things that should be inalienable, no matter what. Whether you are reasonably under threat of them being stripped from you at any given point in time is kind of immaterial — it belongs to you. Computers, especially if you use them a lot which, at this point, a lot of us do, contain much more than simply the hardware and even a handful of documents on them. If you use a web browser, which you probably do, there is a folder on your device called the “cache” which locally stores a ton of information about your browsing history and, it turns out, even entire YouTube videos if you go back far enough. The reason this thing exists is to streamline the browsing experience, so if you leave a page it can be quickly reloaded should you decide to go back. There are also things like all the fonts on your computer, which are sometimes almost as informative for identifying your device as an IP address, because many programs you install download a bunch of fonts. This is informative because the likelihood of another person having exactly the same set of fonts as you is highly unlikely. If you’ve acquired a lot of applications over time, as well, it’s reasonable to assume that a lot of those programs are probably doing things in the background — for example, if you have something like Spotify downloaded it’ll often be pinging Spotify’s servers or loading data to make it quicker once you decide to open the app and listen to music.

The overall point is this: you have a right to ownership over your personal information, the documents you produce, your activity in public and private spheres, and especially sensitive information like health info, bank account numbers, and that kind of thing. Your personal computer probably sits in the middle of all of these — if not then your cellphone does. What makes the Copilot thing especially troubling in this regard is that modern AI systems are black boxes, meaning we don’t really know how they work. Now, in the spirit of being charitable, through extensive testing I’m sure that Microsoft is able to ensure reasonably well that Copilot Recall does follow proper safety protocols. But the problem is that this is one faulty update away from being able to do pretty sinister things if you think about it. And while I am being charitable, I simply don’t trust Microsoft for a very simple reason: I was never asked if owning my PC was important to me. It’s commendable that they made Recall an opt-in feature, especially since the entire tech industry is forcing AI features onto their users without their consent. But the very impetus of my desire to switch to Linux was about ownership, and the most troubling thing to me is that this was never a choice — and it’s arguably a more important one than all the AI stuff.

The Price of Something

There’s a great line in the song “Still Life” by Van Der Graaf Generator I really like: “If we have gained, how do we now meet the cost? What have we bargained and what have we lost? What have we relinquished, never knowing it was there?”

Everything must be met with a cost. This is obvious even if you don’t have eyes to see. Over the last couple of decades, we’ve traded a lot of our autonomy for convenience. I kind of hate talking about stuff like this in terms of “freedom” as well because that word is so semantically bleached at this point. And, realistically, you don’t realistically have more or less freedom if you’re running Windows, MacOS, or Linux as your operating system, so who cares? The issue I have is with autonomy: I need to know that I am making an informed decision about the things I choose. Or, at the very least, I need to know if I’m alright with the uncertainty. After learning about the Recall features, I don’t know if I am. And, to me, that’s enough to question whether I want to stick with Windows or not. To me, the “freedom” afforded to you by Windows includes this implicit “freedom to be spied on” which, to me, is just crazy. There will likely be very little measurable difference in my life after my decision with this. There will even be a slight cost with having to learn everything about Linux. But, the security I’m looking for is with knowing I’m adequately understanding my decision and acting accordingly. And that’s just the definition of autonomy.

~ Jake

A final note

On a final “P.S.” note, I’ve been really enjoying running Linux because it feels kind of like what I imagine that old-school computing from before I was even around but right at that sweet spot where operating systems still existed. I had to use Claude to help me with a lot of things in the early days, but especially after my sojourn into Debian last fall and since I’ve reinstalled it as a complete replacement of that mini PC I mentioned for my homelab, I’ve really gotten into the groove of just “trying shit” and figuring it out as I go. I have also really come to resent how little I’m reading and actually browsing the world wide web now that everything’s being replaced with an LLM overview, so having an excuse to go scrolling through Wiki’s and old forums while a tutorial video plays in the background has been extremely refreshing. I think I’ll still just ask an AI when my only other source is a 20-page Reddit thread that mostly consists of people arguing over nothing. When humans genuinely do fail me, I’ll have to turn to the machines. Still, much of what I’ve learned about OS architecture and why that matters was as a direct result of tinkering with Linux, and I just love that stuff, man.