In April 2019, a friend gave me an iPhone. I gave it a try, and it made me question my life.

The phone

That’s how I actually started using Apple’s stuff full time. The rationale is very simple - there are currently exactly zero models of mobile phones that check all of these boxes:

  • Free software;
  • Open and hackable;
  • Respects the user’s privacy;
  • Actually usable as a phone and a “smart” device.

You always have to compromise on at least one, and usually two or more of these.

Android and other Linux-based mobile OSs allow you a lot freedom in these trade-offs, e.g. you can run CyanogenMod, Replicant, SailfishOS, PostMarketOS, etc. - but you still need decent / supported hardware; and the usability and overall “quality of life” of such solutions are all questionable.

At the far end of the spectrum, some custom ROMs and grassroots OS’s don’t even have a working cellular connection. The best contenders in this area (like SailfishOS, I’ve actually used it daily for 1.5 years!) have very spotty support for third-party apps. At that point, you might also consider using a “dumb” phone.

Both “vanilla” and “flavored” off-the-shelf androids bear the mark of either Google, or the next privacy-violating Power That Be; and in terms of actual software freedom they’re just as bad as Apple’s stuff.

Of course the iPhone is very, very far from free or open. But in a very stark contrast to all the other big name vendors of the world, they actively work to protect their users’ privacy.

I carefully considered, which of these values I held the most dear. I could use PostMarketOS or CyanogenForkOfTheMonthOS, and I would have to suffer for my ideals. I could give my money to Google, and they would still treat me like a product, not a customer. I think I can live with this choice.

The PC

That was a tougher one. dkbox & me wanted to build a proof of concept for a product, and going for an iOS-based platform made the most sense, for several good reasons (mostly technical).

Of course I have absolutely zero experience writing apps for iOS, and my only achievement in the mobile dev space so far has been: for every programmable phone I’ve ever owned, I (re-)wrote that one app, that had only one purpose: display a particular offensive image, to show it to my buddy KK. The Dali Clock kind of an inside joke. The POC we’ve had in mind was setting the bar a bit higher.

There were two main factors that spoke in favor of iOS vs Android:

  • I took dkbox’s Macbook and installed Android Studio & Xcode side-by-side, and tried getting some work done. This is purely subjective - and of course, compared to backend development, mobile sucks - but Xcode sucks a bit less. The simulator is an actual simulator, running native code directly. Swift and Kotlin are basically the same stuff, but the Swift playground was so fun to toy with when experimenting with “data science” (basically what I always wanted from a REPL+editor hybrid, really well done). Not one big thing, but all the little things.

  • For this project, we needed Audio (with a capital “A”), and Android’s audio stack simply sucks. Which is sad, since as Android moved away from several existing Linux subsystems (including audio), it could’ve been the Linux with a good audio stack. (You may know that audio on Linux is an awful mess, but at least it gives you the technical possibility of fixing things. Android’s audio just plain sucks and you have to live with it.)

That was a digression. So, as I kept on using macOS more, I’ve noticed several things:

  • The Mac is a UNIX, and it’s actually very usable on the command line. It’s also BSD-based, and while it has its own flavorings everywhere, it definitely feels very BSD-y.

  • It’s also generally very usable without a pointing device. The default keyboard shortcuts are great; consistent and thought-thru; they worked great for me even as they were radically different from everything I’ve used before. There are also numerous ways to tweak and enhance them.

  • It’s very usable as a desktop. I was never a fan of desktop environments, whether it was MS Windows, KDE, GNOME, XFCE, Unity, or anything else, it usually just annoyed me; I’d stick to a minimalistic shell / window manager, and mostly do my work from the command line. I can’t quite put it in writing, but macOS’s desktop shell is the first one that doesn’t annoy me whole day round.

Notice the pattern? Usable, usable, usable. It was very usable out of the box (even with the initial cost of switching); allowed me the flexibility to customize it and make it even more usable with time; and now, looking back at half a year of daily use, I feel that the need to tweak anything else is rapidly decreasing. Shit Just Works.

Apple, and on the topic of (software) freedom

Think of a particular kind of freedom as one component, a dimension.

I’ve noticed a certain shift in my values, but I had to step aside and look back at the path to see where it led me. I’ve always been a strong advocate for the free software movement, trying to lead by example, contributing where I had the time and opportunity (even if just a tiny bit), and using it wherever it would fit.

Being able to crack open the source, change it at will, share it with a friend, it’s something important to preserve (especially as the spirit of “free software” keeps on getting dilluted by open-core, “look but do not touch”, etc).

However, I realized two things:

  1. Software freedom is just one component part in an individual’s overall freedom; one degree of liberty in a complex, multi-dimensional space, that interacts in complex ways over time.

  2. Openness of software means nothing, if an individual (or entity) doesn’t have the technical expertise and resources to understand, maintain, and ultimately make full use of these freedoms. If making use of freedom puts such a high barrier to entry, the freedom exists only on paper.

Put these two together.

There’s the infamous, extreme example of the Python Qt bindings from a long time ago (00’s IIRC), where the Python source code of the published library was auto-generated, and THAT was covered by the (L?)GPL; with the original source being closed. Technically (on paper), it was free software, with a strong copyleft license. In practice, in terms of actual freedoms it afforded, it was useless garbage.

I’ve been ranting about software complexity for a while, but it’s a sad fact of reality, there’s no escape from it, and the potential of possibility of making use of your freedoms means absolutely nothing, if it exists only on paper - even for experts. (Actual experts, not just power users.) Because to understand the internals of modern software, being an expert is basically a pre-requisite before you can even start the actual hard work.

The grandfathers of the free software movement, the GNU people, are among those to blame for it. (One trivial example, simply compare the relative complexity of GNU cat(1) and OpenBSD cat(1).) GNU has had it as an explicit goal, to make the internal architecture of GCC more complex, in order to make it more difficult to create non-free plugins for it (that could have “worked around” the clauses of their GPL). In doing so, they have subverted the very goal of the project; the freedoms they guarantee exist only on paper. The people that could have made the most use of these freedoms, are being scared away, and instead choose to contribute elsewhere.

But it’s fine. It’s totally fine. I can live just fine, without the comfort of being able to easily add a one-line change to GCC to introduce a new keyword. I won’t ever need it, and if I do, there will be enough toy C compilers for me to try that; and if there were none, writing a toy C dialect for fun is entirely within my reach, and the result will be much more understandable for other people.

Same goes for the kernel, same goes for KDE, same goes for systemd, same goes for Ansible, same goes for every other large, multi-million-lines, many-thousand-contributors project - I have plenty of options, be it writing my own replacement that does 99% of the job in <1% of the code, using a less-complex alternative, or just plugging my ears going LA LA LA and ignoring both the underlying complexity, and the fact that the useless source is available (on paper).

Is complexity always necessary? Is it always avoidable? Neither! It’s a delicate system of trade-offs, and perhaps GCC choosing to be more complex at a rough time, when ideas like software freedom were raising eyebrows at best and were targets of direct assaults of multi-billion corps at worst, was the right choice, leading us to a world that ultimately afforded us many more freedoms.

I do care about the product of all of my freedoms more, than I care about any particular component freedom - it’s a non-linear system of equations, with both an individual’s, and the society’s freedom and quality of life at the outputs. Having my privacy protected not just by strong encryption, but a firm stance? Yes, please. Providing usable, high-quality hardware and software, that enhances my productivity and makes life simpler? Every day. Respecting the natural environment? Naturally.

Apple respects all of that, and it is my hope, that the freedoms this choice affords, lead to a world where we continue to enjoy more of these.

(Side note: yes, Apple is far from perfect - just like anyone else. They have made their share of freedom-violating decisions, but few of us are currently directly in a position to change things. I choose to put my efforts where they can make an impact.)