Author: Jake Bauer | Published: 2023-05-09

I came across a page on Dave Gauer’s site about how he treats different computers as different physical workspaces. That, along with Josh Ginter’s post on keeping a separate creativity computer and Alexander Cobleigh’s post on making a social media computer helped me to put words to the habits I’ve found myself falling into.

Like Ginter, I seem to have a kind of mental block when it comes to being able to easily dive into and stay focused on things like writing, long programming sessions, or reading long-form content on my “primary” computer and it’s hard to articulate why. This mental block doesn’t exist at all when I use my laptop, leading me to use it instead for those tasks.

My desktop computer, with its large 4K monitor and recent CPU and GPU, feels great for doing stuff that fits well on a large screen such as podcast editing or graphics work, but when it comes to concentrating for long periods of time on text-based tasks I find it awkward and tiring. I also tend to use the desktop extensively for entertainment—playing all manner of video games, socializing with friends, and watching various shows, conference talks, and videos—which might be a reason why it feels difficult to concentrate on the kinds of tasks that don’t provide a constant dopamine drip while using it.

Not to say that I can’t use it for those “more productive” tasks; it just seems to take some outside pressure (like an imminent deadline) for that mental block to become less of a force compared to the need to get the task done, and it’s not a very comfortable or enjoyable process as a result.

On the other hand, my laptop, despite its smaller screen and more compact package, doesn’t seem to cause me the same level of fatigue. Even when working at the same desk and sitting in the same chair I’ve found myself much more able to dive into long-form tasks and stay focused on them when using it. For example, I’ve been able to wake up and immediately get right to work on my laptop without any sort of spool-up period, but that would always seem to be a struggle with my desktop. I’ve also been able to sit in front of it for a near six hours straight working on something that I’m passionate about, which I could never bring myself to do on my desktop. (Also, I’ve come to prefer the snappy feel of my laptop keyboard, especially when writing lots of text.)

And, even when I do take longer breaks while using my laptop, I can actually re-focus easily after taking those breaks instead of going down another YouTube rabbit hole like I used to on my desktop because I just couldn’t bring myself to get back into long-form work on what is ostensibly my “entertainment device”.

So, there seems to be something to this idea. That, much like having a separation between physical “work” and “play” environments leads to being better able to keep the two separate with both mental health and focus benefits, the same seems to be true when it comes to using different computers for different purposes, even when the actual physical environment around me doesn’t change.

Plus, setting up those different computers with different environments optimized—or at the very least tuned—for some particular set of tasks makes it easier to concentrate and stay focused on those tasks when in that environment and provides even more of a separation between a computer that is used for play and one that is used for work.

As Gauer mentions, this idea might seem a bit extravagant and wasteful, considering that there are many who can hardly afford one computer, let alone several. He mentions that relatively powerful computers are quite inexpensive these days, especially on the second-hand market, but I’d also like to add that a separate physical computer might not even be necessary. If you are strapped for cash or simply don’t want another thing in your life, a separate user account with a different set of programs installed and a different look and feel on the same physical computer might also work.

If you’ve noticed the same trouble getting or staying focused on tasks using the same device you commonly use for entertainment, perhaps give this a try and let me know how it works out. If you have any tips to share about using computers this way I’d be happy to hear them too.

Until next time,
~jbauer

Author: Jake Bauer | Published: 2023-03-17

(Yes, I totally ripped off jcs’ format for this.)

It’s been a while since I had a laptop with any semblance of computing power that I actually enjoyed using.

Back in 2021, I ditched my Thinkpad T420s for a Mid-2009 MacBook Pro and an old 2008-era netbook, both with Core 2 Duo series processors. Although the MacBook is still usable for most non-browser-heavy tasks, I just fell in love with portability of the netbook which led me to see if I could find a newer, more powerful laptop that would fit my preferences. I created this page to compare laptops that looked like they might fit what I wanted.

Basically, I wanted a laptop that was small, thin, and lightweight, but also high quality and not too expensive. I don’t need a ton of performance, I didn’t want to spend a lot of money, and I prefer not buying new things whenever I can, so I opted to get something from the used market. I hopped on eBay, did a whole lot of searching, and eventually landed on this.

With this new laptop I’ve launched myself 10 years into the future… from 2009 to 2019!

Table of Contents

• Hardware
• Firmware
• Power and Heat
• OpenBSD Support Log
• Current OpenBSD Support Summary

Hardware

The Dell XPS 13 9380 is another laptop in Dell’s revered XPS line. Known for excellent build quality, nice keyboards, beautiful screens, and good battery life, this model doesn’t disappoint. I managed to snag a version with an Intel i7-8665U, 16GB of RAM (soldered), a 256GB SSD, a 1080p touchscreen display, and a dead battery; all for a very reasonable price and in great physical condition.

The dead battery is probably how I was able to get such a recent, fairly high-end machine for only C$500 ($365 USD on 2023-03-16) before shipping and taxes (an additional C$90) where comparable models were at least C$150 more expensive. I have ordered a replacement 52WHr battery (C$60), but until it arrives I can rely on being plugged into the wall and hibernating whenever I need to move.

The chassis is made of CNC machined aluminium and the palm rest of a soft, comfortable carbon-fibre composite material. The build quality is excellent; reminiscent of MacBooks. It also has minimal yet tasteful branding in the form of an encircled Dell logo on the lid and silver “DELL” text in the middle of the bottom display bezel. The palm rest does have a tendency to pick up fingerprints, but it’s easily cleaned.

On the right side of the laptop is a headset jack, a USB Type-C port, a micro SD card slot, and a speaker.

On the left side of the laptop is a security cable slot, two Thunderbolt 3-enabled USB-C ports, a battery charge status button and indicator, and another speaker.

The laptop can be charged and can output to an external display using any of the three USB-C ports. The Thunderbolt 3 ports would theoretically let me plug in an external GPU if I wanted to do away with my desktop altogether, but that wasn’t a consideration when I got it.

The speakers are nothing stellar. They sound a bit blown out at max volume and don’t have a great bass response, but they don’t sound terrible either and work in a pinch. They sound like they respond best in the mid-range, which is where most human voices land, and they performed quite well when listening to a podcast at about 65% volume.

There is a really small 720p webcam at the top of the display providing a decent enough picture quality. I’m glad this is at the top of the display and not at the bottom looking up into the user’s nose, unlike on previous models. There is also an array of four microphones at the front of the palm rest, just above the charge indicator light, which provides audio of an acceptable level of quality. Both are disabled by OpenBSD by default and can be disabled in the BIOS.

The 13.3” 1920x1080 glossy, touchscreen display looks crisp, vibrant, and clear. Despite it only having 165 PPI, it’s sharp from reasonable viewing distances and has the added bonus of using much less power than the alternative 3840x2160 display. The display can reportedly reach a peak brightness of 400 nits, but I use it at about 10-20% brightness when indoors. It is by far the best display I’ve had on a laptop. I would have preferred a 16:10 or 3:2 aspect ratio, but that’s only recently come back in vogue so I would have had to pay twice the price or more for a laptop with that feature.

The hinges of the display are stiff and don’t wobble at all when typing or when moving the laptop around. They are still loose enough that you can mostly open the laptop with one hand, though it will start to tip backwards when the display is approaching 80°. The screen also closes with a satisfying thud.

The keyboard is Dell’s typical, crisp, chiclet-style keyboard that was common across all their XPS laptops until more recent models. I enjoy the tactility of the keyboard, which doesn’t flex at all during normal typing.

The trackpad feels soft and smooth, though the physical click noise is a bit loud and high pitched as opposed to a satisfying clunk like on MacBooks. This isn’t such a big deal though since tapping works just fine.

There is no audible coil whine or fan noise at idle. When the laptop is under heavy load, the fan does noticeably spin up but stays relatively quiet. Ultimately, I would have preferred something fanless, but the fanless laptops I could find that also satisfied all of my other preferences were quite expensive.

Wireless connectivity is provided by a soldered Intel Wireless-AC 9260 WiFi 5/Bluetooth 5 chipset, which is unique to models of this laptop which come with an i5-8365U or i7-8665U processor. In models newer than the XPS 13 9350, XPS laptops have come with soldered Intel Killer WiFi chipsets which are not supported on OpenBSD. This model is unique out of the newer XPS lineup in that it has this other WiFi chipset option; neither the preceding or succeeding models seem to have it.

The NVMe SSD is a 256GB Micron 2200S in a removable m.2-2280 form factor. I use 256GB SSDs in almost all of my machines, so this size is adequate for me, but I can always upgrade the storage if I need to in the future. I ran CrystalDiskInfo on Windows 10 before wiping the drive, and it reported that the SSD has about 84% of its life remaining with ~15TB written to it so far.

Firmware

Pressing F2 at the boot splash screen will take you into the BIOS Setup menu. The 9380 has Dell’s typical Windows 7-styled graphical BIOS which is fine and does the job. There are plenty of options available from battery management to turning off ports and peripherals.

As usual, Secure Boot must be disabled in order to boot OpenBSD.

You can select a temporary boot device or access other functions by pressing F12 at the boot splash screen.

There is also an embedded diagnostics tool which will run the hardware through various tests. I’m not sure how good this is at detecting most faults, but it is a nice thing to have to quickly check that all the hardware is most likely working (it did yell at me about the battery).

Power and Heat

One very important thing that I want from my laptops is for them to not get too hot or too loud. That is one of the main reasons I stopped using old Thinkpads.

This model performs admirably. During light workloads the fan is silent or inaudible in my typical working environments and is quick to spin down after heavy loads. When the fan is spinning, it doesn’t produce an annoying or high pitched sound, just a noticeable “whooshing”.

At idle, the XPS 9380 sits around 45°C, probably because the fan is not programmed to ramp up until the processor gets warmer. I am fine with this behaviour, as it means that my regular workloads are not likely to make the fan spin up. Also, I can run the laptop at minimum clock speeds using ampd -L, in which case the fan almost never comes on and I don’t notice any drop in performance for most of the things I do with the machine.

During normal use, the underside of the laptop gets warm, but not at all hot. The temperature of the palm rest and keyboard does not noticeably change.

I’ll have to wait until the new battery comes in before getting an accurate measure of battery life, but for now I measured the laptop pulling about 11.5W from the wall during my normal use, and 27W with the screen at full brightness while running:

stress --cpu 4 --vm 4 --vm-bytes 1024M

Update 2023-03-14: The new battery has arrived. I installed it (alongside a quick clean-out of the fans and heatsink) and did a full charge, followed by a discharge to 0%, followed by a charge back up to full in order to calibrate it. As far as power draw, it looks like OpenBSD draws roughly 8-9W at idle and Linux can go as low as 1.5-2W. Battery life is roughly 5-6 hours on OpenBSD and estimated at 9-12 hours on Linux, depending on the workload and screen brightness. This makes sense given that OpenBSD does not implement a lot of the powersave functionality in most (if not all) of its drivers.

OpenBSD Support Log

2023-03-14: The only thing that didn’t work well out of the box was resuming from sleep or hibernation. When doing so, the screen would turn on, the laptop would appear to try to draw to the screen (various lines and columns in the text mode console were replaced with black), but the laptop would freeze completely, stop responding to any input, and could only be reset by holding the power button down until the laptop turned off.

2023-03-15: After a good bit of research, I stumbled upon this openbsd-bugs thread about the Framework laptop which had a solution that worked.

It turns out that disabling at least one of the devices handled by the dwiic driver causes resuming from sleep and hibernation to work properly again. The two dwiic devices I see are dwiic0 corresponding to ELAN2931 (the touchscreen) and dwiic1 corresponding to DELL08AF (the trackpad). Because the trackpad still works without dwiic1 being active (it gets handled by the pms driver instead), I opted to just disable that and leave the touchscreen working. Of course, disabling dwiic outright also fixes the issue, but leaves me without a working touchscreen.

This is the command I ran to make the changes permanent (though I do have to repeat it every time I sysupgrade(8) to a new kernel):

$ doas config -ef /bsd
ukc> find dwiic
226 dwiic* at pci* dev -1 function -1 flags 0x0
448 dwiic* at acpi0 flags 0x0
ukc> change 226
226 dwiic* at pci* dev -1 function -1 flags 0x0
change [n] y
dev [-1] ? 21
function [-1] ? 0
flags [0] ?
226 dwiic* changed
226 dwiic* at pci* dev 0x15 function 0 flags 0x0
ukc> quit

2023-03-16: After much more testing and trying new snapshots and updating the BIOS and so on, I sent a report to the openbsd-bugs mailing list using the sendbug(1) utility, so we’ll see what people more knowledgable than I can make of this problem.

2023-04-13: I also had an issue where the laptop would immediately suspend again if I closed the lid to suspend it and then opened it back up. This issue was also noticed and solved by Todd C. Miller, who provided a simple patch that is now in the OpenBSD kernel. No progress on figuring out my freeze-on-resume issue, though Todd may also be having a similar issue. When I get some time, I’ll see if I can replicate the behaviour they are seeing.

Current OpenBSD Support Summary

Status is relative to OpenBSD-current as of 2023-03-17.

Author: Jake Bauer | Published: 2023-03-02

Long time no see! While I have a few other, longer blog posts still cooking, I figured I’d post about a cool bit of CSS I came across on eli_oat’s site which adds a marker to every link on a site that points to an external domain.

This means that links which point to pages on the same site (or within the same domain, if configured like that) look like this: paritybit.ca, whereas links which point to any external domain look like this: example.com.

I find this super useful on sites like Wikipedia so that you know when clicking a link will take you off the site or if it will just take you to another Wikipedia article. I find it equally useful for sites that are also personal wikis or which frequently reference a mixture of original and external content. If that sounds like your site, I encourage you to add this bit of CSS too!

The original CSS as pilfered is:

a[href^="http"]:where(:not([href*="domain.tld/"]))::after {
    content: "⬈"
}

Which selects all <a> tags with attribute href beginning with "http", but not those which contain domain.tld/, and adds an arrow symbol after the text inside of those tags.

For my site, I’ve changed the arrow symbol to be skinnier (U+FE0E U+2197) and made sure this only applies inside of <article> tags so that my <nav> and <footer> are not affected. I’ve also written another small bit of CSS to make sure that clickable images that lead to an external domain don’t have an arrow next to them (because that looks a bit awkward). The CSS on my site is:

article a[href^="http"]:where(:not([href*="paritybit.ca/"]))::after{
    content: "︎↗"
}

figure a::after{
    content: "" !important
}

Images on my site are always within figure tags, and tend to be structured like:

<figure>
    <a href="example.com">
        <img src="example.com/img.png">
    </a>
    <figcaption>An image</figcaption>
</figure>

which is why this works for me, though this could also be done by adding something like class="img" to the <a> tags and using that to select them instead.

If you’re using a customizable static site generator and want to make this work without CSS, or in browsers which don’t support all these CSS features (such as NetSurf or fairly old versions of Safari), you could add something similar to your website build pipeline that appends the symbol to every external link.

Another way this can be accomplished is by using the rel attribute in the anchor tag as detailed in this post by Martin Christiansen .

Author: Jake Bauer | Published: 2021-11-08 | Updated: 2023-07-27

I used to be a staunch software freedom evangelist. I used to license all my works GPLv3-or-later and CC-BY-SA wherever I could and I used to believe strongly in the words of Richard Stallman. I have since started to think more about the real effects of the Free Software movement and have changed the way I write and license my software as a result. Although I believe FOSS as a concept is still very important, I simply no longer believe in the Free Software movement.

I’ve come to the conclusion that Free Software is an abject failure. While Free Software may on its face sound like a good concept—especially with the kind of language often used to describe the movement and its opponents—when put under scrutiny, the institutions and practices that make up the Free Software movement fundamentally fail at their stated goals. The Free Software movement is doing more harm to FOSS than good.

Not only is it an ideological mess, it hampers collaboration, it is legally ineffective, it makes the lives of developers harder while doing nothing actually useful for users, and it fundamentally gets in the way of a thriving, free, and open software ecosystem.

The Failure of the Free Software Ideology

Why Software Should Be Free by Richard Stallman presents an argument against having owners of software and explains the harm done by obstructing software development through proprietary licensing. He posits that software with obstructions results in fewer users, the inability for users to fix programs, and the inability of developers to build upon prior knowledge or work. He also states that the justifications one uses for keeping ownership of the software (which he equates with keeping the software proprietary) are emotional (i.e. “This software is mine, and I wish to control it”) and economical (i.e. “I wish to become wealthy by programming.”). He shuns these excuses and spends the rest of the document refuting those excuses and explaining why the existence of proprietary software is bad and why the alternative—software not having owners—is better. By and large, I agree with this essay.

However, in nearly every Free Software project which exists today, there is a clear “owner” of the software—someone who is the copyright holder, benevolent dictator for life, or simply de facto leader of the project and through whom all contributions must flow. Whether we’re talking about large projects that are too large to fork and maintain by anybody but large, well-funded groups such as the Linux kernel (in which Linus still has complete veto power by the way), Qt (in which the company controls the development of the software and simply allows older versions to be used under a free license), or Android (where Google maintains pretty solid control), or smaller projects which have simple leaders. As long as there is a copyright statement, there are one or more owners to be aware of.

Additionally, the GNU Manifesto, aside from calling the Open Source movement an “amoral approach”, goes on to say that GNU “is not in the public domain” and will have restrictions placed on further modifications (in the form of disallowing proprietary modifications), with the justification given by Stallman being: “I want to make sure that all versions of GNU remain free.” With that, Stallman falls upon the same behaviour that he previously shunned in Why Software Should Be Free. He uses his emotional attachment to the software, something he said was an excuse to defend why software has an owner, to justify his want to control how others can distribute and modify his code. He is effectively saying “this is my creation, and I wish to control what others can do with it” while also clearly assigning an owner to the software.

Update 2021-12-13: I was recently made aware of an article in which Richard Stallman advocates against positive changes to copyright laws because of how it would hurt Free Software. Instead of making software free of copyright after 5 years, he advocates for maintaining copyright control because it would hurt the control that Free Software licenses would have over the distribution of software later on. It’s not enough that the software would still fulfill the four pillars of free software after the 5 years is up, control must be maintained over how other people can distribute and use the software in their products in case they ever decide to fork it and make something proprietary from it. Not only does he not trust that people would use only the Free version (as if we need to be protected by Free Software licenses lest we use some proprietary software), he is, in essence, advocating for maintaining ownership over software even though the change to copyright legislation would be positive for society overall. The article is called: How the Swedish Pirate Party Platform Backfires on Free Software.

If software is not in the public domain, then, by definition, it has to have at least one other owner. If Stallman can dictate how others can use his software—even if it is more free than most proprietary software—then it clearly has an owner.

Simply put, Stallman and others in the Free Software community use the exact same excuses that he criticized in Why Software Should Be Free as justification for their actions. GNU, the GPL, and seemingly the entirety of Free Software as it stands today are all based on the same premises as proprietary software. They use existing copyright systems in what they deem the “right” way while simultaneously criticizing the way others use them as wrong.

The Free Software movement comes off as both a “cult of personality"—worshipping Richard Stallman and his teachings while ignoring the inconsistencies between his words and his actions—as well as a “cult of ideology"—shunning those who disagree with the manifestos and the “way of life” that the movement espouses to an extreme degree. As long as you, as a developer, do everything within the framework of the GPL and the culture of Free Software, you are considered ethical and good. As soon as you wish to do something outside of this domain—even by using a more open, permissive license—you are considered amoral.

In an article where Linus Torvalds criticizes the GPLv3, Torvalds even says:

“I think the GPLv3 is expressly designed to not allow [the meeting between open source and free software people]. Exactly because the FSF considers us open source people ‘heretics.’”

The Failure of the GPL

One of the stated goals written in the GNU Manifesto is:

“Finally, the overhead of considering who owns the system software and what one is or is not entitled to do with it will be lifted.”

One look at the GPL or any other Free Software license will tell you that they have utterly failed at this. For example, the GPL has become so complicated that only a programmer with relatively advanced legal knowledge and ability to read and properly understand “legalese” will be able to decipher it to know what they are able and unable to do with it. There exist websites which explain the license in plain English, but even those say their explanations are no substitute for reading the license. There are very specific meanings that many of the words in the license take on when put in the context of our modern legal system so, while you may be able to read the GPL and think that you understand it, unless you are well-educated in “legalese”, you probably don’t fully understand the true meaning and effect that the words of the license would actually have in court.

The ramifications of the GPL are still not even fully understood by lawyers themselves. Many large companies will shy away from the GPL simply because they don’t want to take the risk of using GPL-licensed code improperly and being forced to reveal their proprietary software. While I don’t agree with proprietary software as a concept, the fact that even lawyers—who are supposed to be expertly trained in the kind of language used in the license—are uneasy about its terms further reinforces just how unapproachable it is to the everyday software developer. GNU and the GPL have done nothing to remove the overhead of considering who owns software and how it can be used.

Update 2023-07-13: It has become especially clear how few people actually understand what the GPL does and does not permit based on the responses to changes that Red Hat made to how they offer their source code (more on this later).

Since the development of the GPL is reactionary—that is to say, its development and growth over time was in response to discovered workarounds—there is now even more overhead by way of the extra complication of the “-or-later/only” clauses. So this is now a license that has multiple versions which are not backwards compatible. A project licensed under the GPLv2-only cannot integrate GPLv3-or-later code without being re-licensed as GPLv3. The Linux kernel is an excellent example of this.

Linus Torvalds even came out strongly against the GPLv3 and the process by which the FSF created the license. Many others in the industry also saw this as an extreme and unnecessary move by the FSF to wield the ultimate power over the GPLv3; all because a manufacturer put Linux in their products and blocked users from running their own modified software on that hardware. The absurdity of this line of thinking is compounded by the fact that this had absolutely nothing to do with the Linux kernel since it’s the system’s firmware that would stop users from running different software. This seems to many as just an excuse to expand the scope and powers of the GPL over something completely out of the scope of the GPL-licensed software. The move by the FSF, the actions of Stallman, and the “tivoization” rhetoric are even heavily criticized by Software Freedom Conservancy member Bradley M. Kuhn.

Putting aside the political manoeuvrings of the FSF, the mere existence of an “-or-later” clause is a ridiculous thing to attach to a license. Anybody who licenses their project under a GPLv3-or-later license puts a lot of trust in the stewards of the GPL that the next version of the GPL will align with their values and goals; a GPLv3-or-later project will be able to be licensed under a GPLv4 license whatever the clauses of that GPLv4 license. This is a lot of stock to put into a group of people like the FSF who were so dogmatic and exclusionary in their development of the GPLv3.

The reality of the GPL is that there is still a lot of overhead in considering who owns the software and how it can be used. Not only in whether or not a developer should choose version 2 or version 3 of the license depending on their goals, but also for developers and users alike who try to understand the language of the license to determine what they can do with the software and, if they are integrating some GPL-licensed code into their own product, who actually owns and has copyright over that software.

Those who wish to integrate GPL-licensed code into their otherwise non-GPL-licensed projects are faced with the decision to relicense their code under the GPL, remake the functionality of the library under a more open license, or otherwise abandon those efforts altogether. While the GPL may “prevent” corporations or people from taking GPL-licensed code and integrating it into a proprietary product, it also prevents literally any other non-GPL-licensed project from using GPL-licensed code, even other FOSS projects.

Even so, it’s not like the GPL actually prevents corporations from stealing GPL-licensed code and integrating it into projects. While there are plenty of corporations who freely comply with the GPL, there are plenty more, such as VMWare, who don’t comply and yet don’t face consequences. Even if a lawsuit is successful, it is usually at the cost of members of the FOSS community who burn out or are left disenchanted by the whole process. Being GPL-licensed also doesn’t prevent a project from being bought and therefore having all control handed over to a corporation. This was most recently seen in the acquisition of Audacity by Muse Group in which Muse Group bought the rights to the Audacity code and project. Users have since forked the project, but this doesn’t necessarily stop something like this from happening in the future, and certainly doesn’t stop it from happening to other projects. If software actually didn’t have owners, this could not happen.

Update 2022-10-23: It just happened to Gitea!

Update 2023-07-16: Being under the GPL also doesn’t even stop projects from being closed-source except to paying customers. As just happened with Red Hat Enterprise Linux! Red Hat is making Red Hat Enterprise Linux’s source code available only to paying customers. Since there’s no other way to get a copy from Red Hat (you can’t just download it like you can Ubuntu), this is entirely within the letter of the GPLv2. They’ve also said they’ll terminate support contracts and not give customers new versions of the code if those customers exercise their rights under the GPL by distributing the code they receive from Red Hat. This angered a huge portion of the FOSS community who shouted from the rooftops about how this violates the “spirit” of Free Software. However, this is nothing new, and a company was doing the same thing in 2006 to which the Free Software Foundation said “that’s ok!”. That “spirit” clearly doesn’t matter when it comes to a company’s bottom line and neither the GPL nor the FSF do anything to address this.

The GPL-family of licenses attempt to solve a societal problem by restricting the distribution of software in a manner not unlike the so-called Ethical Software movement. The GPL acts effectively as a proprietary license that allows you to do the things it deems ethical, so long as you abide by the terms of the license with regards to the distribution and re-licensing restrictions. As long as you are in this “club”, everything is fine and dandy and you can make your changes and push them to your favourite projects. As soon as you leave this club and want to pull code from a GPL-licensed project into your MIT-licensed project, well, sorry, too bad for you.

While the GPL may not cause as much of an obstruction or be as unethical as proprietary software, it is frankly not that much better. It causes distress and conflict in the software community, is difficult for non-lawyers to fully understand, and harms developers of non-GPL-licensed FOSS software all while not even being effective at what it was ostensibly designed to do. It is, for example, the reason why the BSDs cannot take improvements made in the Linux kernel and directly integrate them into their own kernels and it is the reason why ZFS cannot be integrated into the Linux kernel, but can be shipped with FreeBSD.

For all this talk of Free Software being the ethical option and the GPL being the ultimate defender of user and developer rights, it completely goes against the ethical principles laid out in Why Software Should Be Free. So much for “free as in freedom”.

The Failure of the Free Software Culture

The GNU Manifesto speaks a lot about how:

“Users will no longer be at the mercy of one programmer or company which owns the sources and is in sole position to make changes.”

But a cursory look at the current landscape of Free Software will tell you that this is simply not the case at all.

Users are absolutely at the mercy of the maintainers of software projects to integrate their changes in the current landscape of software development, especially with software projects as complicated as many of the popular GUI toolkits, kernels, or desktop environments. In fact, the reality is that Free Software project issue boards and forums are not much better than corporate support forums. Often when one opens an issue in a large software project it can take months or even years for those issues to be worked out. It’s also not uncommon for those issues to simply go unsolved for many years. A great example of this is the ‘Add an “icon view with thumbnails” mode’ GNOME issue which was opened in 2004 (it’s almost old enough to vote!) and is still not actually fixed despite many users expressing how useful it would be to have this featureapparently has been recently added nearly 20 years later. Good job everyone!

Users simply cannot maintain such complex software on their own and, if they have limited programming ability, cannot be expected to fork a project, make their fix, test their fix, act on feedback from the maintainers (if they’re lucky enough to get their patch or pull request noticed), and so on. The current software development ecosystem makes this impossible, regardless of the license of the project. Software is not yet simple enough for that and GNU and Free Software did nothing to solve this. In fact, it can be argued that they made this worse by contributing to the creation of a culture of “elitists” who expect all the users of their software to have the ability to read code and very technical discussions or documentation in order to understand and fix problems.

If an experienced user does come along and is dis-satisfied with their corporate support forum-like experience, they might be inclined to fork the project. However another very common sight in the FOSS realm is to see accusations towards groups or companies who fork projects of making “hostile forks” or committing “theft” of Free Software. For example, Members of the Free Software community shunned and criticized the group of developers who forked Gogs to make Gitea when they forked a Free Software project to extend it for their own needs because of an unresponsive maintainer. They even still kept the project under the same license (an “unethical” Open Source license, no less).

Update 2022-09-13: I recently learned of the XFree86 fiasco in which another, similar incident occurred where one of the original developers of the X window system felt that the current state of things was untenable and that the project needed to be forked and replaced. He was summarily shunned and kicked from the project for his actions. This is yet another example of how forking is viewed by many who work in FOSS and who wish to maintain control over their particular piece of software.

If software is not supposed to have an owner, as Why Software Should Be Free advocates, what exactly is being stolen? Why do they, as the creator of some piece of software, care if some company or even another FOSS developer takes it and uses it in their product or makes proprietary modifications with it?¹ Why Software Should Be Free specifically outs this need to control what happens with one’s software as one of the main justifications for proprietary licensing and something to be avoided, yet it is seen everywhere in the Free Software culture. In fact, an article entitled Don’t fear the fork: How DVCS aids open source development perfectly exemplifies how the Free Software culture views forks (of course, it’s written from the perspective of the “amoral” Open Source movement).

The goal of Free Software as laid out by Why Software Should Be Free was to create a world in which there were no owners of software and in which distribution was not restricted. Yet, despite this, the way the GPL family of licenses puts restrictions on the distribution of GPL-licensed software combined with the culture of Free Software actively encourage both of those things and actively discourage forking software and modifying it to suit your own needs. From the point of view of Why Software Should Be Free, the GPL combined with this culture is, in reality, hardly much better than the world of proprietary software we had before as far as users (and developers to a lesser extent) are concerned.

The degree of openness which exists in the current software landscape can be, to a large degree, attributed instead to the Open Source movement². It happened in spite of the Free Software movement, not because of it.

The Failure of Free Software to Remain Relevant

Free Software and the surrounding culture and institutions are often viewed as a farce outside of the dedicated Free Software cult community. The FSF has been slowly descending into irrelevancy for the past two decades as they struggle to do anything meaningful with their time and resources; instead opting to make a lot of unproductive noise. Take, as recent examples, how they mailed a hard drive to Microsoft telling them to put the Windows 7 source code on it, or how they accuse Apple of “censoring free software” —despite the fact that Apple isn’t actually censoring anything and plenty of Free Software projects such as Telegram are on the App Store—and also criticizing them for not supporting their specific chosen free media codecs—once again, ignoring the plenty of other free media codecs which are otherwise perfectly supported.

To expand on that last point about Free Software projects on the App Store, the Apple App Store EULA contains restrictions that the GPL doesn’t allow (see section 10 of the GPLv3 and section 6 of the GPLv2). It says:

Except as provided in the Usage Rules, you may not distribute or make the Licensed Application available over a network where it could be used by multiple devices at the same time. You may not transfer, redistribute or sublicense the Licensed Application […] You may not copy (except as permitted by this license and the Usage Rules), reverse-engineer, disassemble, attempt to derive the source code of, modify, or create derivative works of the Licensed Application, any updates, or any part thereof…

Note that this only applies to the application you purchased in the App store, as bundled by the App Store. It doesn’t prevent you from going to GitHub and modifying the software there, it only prevents you from legally modifying the software you got from the Apple App Store. Sure, this isn’t a good thing and it can be easily argued that this is unethical because you don’t ever own the apps you purchase, yet it is hardly “censoring free software” given that, as the owner of a Free Software project, you can freely submit GPL-licensed software to the App Store and Apple assumes you have the rights to provide them with a non-GPL-licensed build.

If you don’t have that ability because you don’t own exclusive rights to the software and it’s not feasible for you to get the permission of every contributor with their name attached to the project, well, that’s not Apple’s problem. The FSF words their article like Apple is attacking them when, in reality, Apple doesn’t care what license you’ve chosen, only that you grant them the ability to distribute your app under the terms of their EULA. The wording in that blog post is yet another example of why the FSF are seen as a farce. They should know better.

This reputation of preferring ideological book-thumping over meaningful action is nothing new. Most who are familiar with Linux are likely familiar with Richard Stallman’s “GNU+Linux” rant in which he squabbles and nitpicks over the relevancy of GNU to the Linux name. Ignoring that the only significant contributions to the Linux system GNU can claim is the compiler, the coreutils, and the C library. While these used to be relatively significant in the early 90s, most Linux systems today run far more non-GNU software than GNU software.

In fact, even those GNU components are quickly fading into irrelevancy as projects like Clang/LLVM, rewrites of coreutils to be faster and cleaner (e.g. Busybox or various Rust projects), and other libc’s such as muslc are gaining more and more traction with each passing day. GNU is simply failing to make any meaningful and actual progress, and is grasping at straws in an attempt to remain relevant. Not only have other projects such as OpenBSD long since abandoned things like modern GCC due to later versions becoming unmaintainable, buggy behemoths, GNU themselves haven’t even released their HURD kernel in any meaningful capacity despite promising to create such a thing since before Linux existed.

Speaking of fading into irrelevancy, many of the Free Software institutions such as the Software Freedom Conservancy and Free Software Foundation Europe have either been reliant on GPL violation lawsuits as one of their primary means to exist, or have been relatively ineffective at carrying out their mandates with regards to litigation. It has gotten so bad that the SFC have tried to bring lawsuits on behalf of the users of GPL software; something which has little basis in actual copyright law, but is the only option they have left when companies either skillfully hide their GPL violations or the owners of GPL software are unwilling to enforce the license against large opponents. A cursory glance on the SFC’s website reveals a lot of information about this Vizio lawsuit, but not much information about previous lawsuits or successes. No wonder these institutions also tend to only go after small opponents. Even very public violations such as those committed by OnePlus have still gone unanswered for. If such violations are clearly allowed to continue with such ineffective enforcement, what even is the use of the GPL in reality?

Regarding the quality of GNU software, outside of the Free Software community, GNU code has a reputation for being resource-hungry, buggy, bloated, or annoying and frustrating to work with, as many who have had the pleasure of using alternative libc’s, compilers, utilities, or programs will attest. GNU creations have a reputation for being needlessly complex—solving problems which don’t really exist in the first place if you write good software (or documentation)—and having bafflingly complex source code. The GNU Info system and the code found in many of the coreutils are good examples of this.

Finally, we can talk about how the conduct of Richard Stallman himself reflects on the whole Free Software movement. The Free Software movement went through its own little “constitutional crisis” over the question of whether or not to keep him on as the face of Free Software after he made some comments on an MIT mailing list about a sensitive topic. I won’t go into specifics about that situation here, since it has been covered to death in other media outlets and can be easily searched for (search “stallman mit mailing list”), but, suffice to say, Stallman acted in a completely improper and inept manner and, in fact, that is far from the only example of him behaving in such a way.

In 2007, Stallman sent a message to the OpenBSD-misc mailing list entitled “Real men don’t attack straw men” in which he accuses the OpenBSD folk of making straw-man arguments about himself, and then using those arguments to attack his credibility. If you read through this mailing list thread, you don’t have to go far to realize that Stallman has absolutely no clue what he’s talking about. He bases his opinion of OpenBSD on “what I have heard” and presumes that the OpenBSD folk care whether or not he recommends their system. He proceeds to have everything he said get taken apart by the replies which point out all the inconsistencies in his own arguments and stances.

After seeing just how ineffective this culture is at advocating for and enforcing its principles in a meaningful way, as well as seeing the conduct of one of its top-most members, how could anyone view this as a movement to be appreciated, let alone joined and celebrated?

Where Do We Go From Here?

I think, by now, it is accurate to say that Free Software is an abject failure.

It has failed at its stated goals through both the licenses and the culture it has created and has instead perpetuated the paradigm of software ownership and the use of unethical and flawed copyright legislation. It has done very little to prevent corporate takeover of projects, improve the software development landscape, or make the lives of developers or users easier. It has done nothing that more ethical, permissive software licenses and the culture of collaboration born out of projects such as BSD Unix didn’t already do, except to create a toxic subculture of Free Software cult worshippers.

One cannot solve the copyright, ownership, or restricted distribution problems of software through playing into the exact same flawed systems that allow such problems to exist in the first place. These are problems which must be solved on a societal level, not on the level of individual software projects through an obtuse license. Free Software, as it stands today, has the very real effect of restricting innovation, sharing, and collaboration between developers.

None of this is to say that proprietary licenses are okay or even that the Open Source movement is the alternative. In fact, the Open Source Initiative is not all that much better than the Free Software Foundation, it just has a mostly different set of problems which are out of scope for this essay.

For the most part, I agree with Why Software Should Be Free. Stallman has perfectly valid and good ideas in that essay, yet he misses the mark with their implementation. He’s right in that software should not have owners and restricting software distribution is unethical; I ultimately believe that nobody should get to control how their software is used, studied, distributed, or hacked upon. Software should be as much in the public domain as possible just like books, music, product schematics and other such things should be.

The only licenses which truly meet all these criteria under that framework are public domain-equivalent licenses. Licensing your code under the Unlicense, the 0BSD License, or the CC0 License means that you do not place any restrictions on the software whatsoever. People don’t even have to mention your name or your project when they use your code because you are no longer the owner of that software.

If you do at least wish to have your name attached to the code, commonly used permissive licenses are the best option. Licenses such as the MIT License or the ISC License (preferred due to it being a simplified MIT) impose no further restrictions other than maintaining a copyright and permission notice for that code if it’s used in other projects. Essentially, people are free to do whatever they want with your code, so long as they keep your name on parts that you wrote.

Not only do these options provide far more real freedom to developers³, they remove the overhead of having to think about who owns the software. In the case of software in the public domain, you don’t have to worry at all because there is no owner. In the case of permissively-licensed software, it’s a simple matter of copy-pasting the necessary notice(s) wherever that code is used. These licenses are also relatively easy to understand (except perhaps the CC0), and the culture surrounding them is generally such that you don’t have to worry about a mob coming after you for forking a project and morphing it into something that serves your needs, nor do you have to worry about being sued for an accidental violation of a license that even people who are well-versed in software licensing aren’t confident about getting right.

You’ll notice that those licenses, however, do not address the issue of corporations controlling software development and distribution, people using software in ways you may deem bad or harmful, or the existence of megasoftware. This is because those are problems that cannot be solved or even effectively addressed by software licensing. These are societal problems that must be tackled on a societal level. Attempting to do otherwise simply harms and imposes more restrictions on small teams, independent developers, and hobbyists who don’t have the resources to ignore your restrictions or buy your development team.

In reality, by licensing your project under the GPL and participating in Free Software culture, instead of limiting the harms that corporations inflict, you end up limiting the good that the rest of us can do. Free Software has failed.

Author: Jake Bauer | Published: 2021-10-26

When sending or receiving patches to or from git repositories, I prefer to use git send-email. I find this workflow more efficient and less distracting than jumping to a web interface to create a pull request. Plus, it’s not dependent on having an account wherever a repository is hosted.

I used to use aerc as my email client, but have since switched to Claws Mail as I find TUIs with multiple windows, tabs, and panes to be awkward to use. However, aerc came with some really nice features for software development which aren’t available in Claws Mail. Watch the video at the link for aerc above to see those features in action.

Sending emails with git send-email is easy and switching to Claws Mail required no changes to my workflow because it does not interact with an email client at all. On the other hand, patches sent to me do end up in my email client so I needed a way to quickly and easily apply the patches I receive. Luckily, it’s fairly easy to do this with Claws Mail since it is quite extensible.

First, I needed to write a small script to parse the email and extract the repository name from the subject line so the patch can be applied to the correct repository. Then, the script cds into the repository and uses git am to apply the patch. Here is the script:

#!/bin/sh

projectsDir="$HOME/Documents/projects"
patchFile="/tmp/patch"

IFS=''
while read -r line; do
    echo "$line" >> "$patchFile"
    if echo -n "$line" | grep -q "^Subject:"; then
        repo=$(echo "$line" | grep -o '\[PATCH .*\]' | cut -d' ' -f2 | tr -d ']')
    fi
done

echo "Applying patch to: $projectsDir/$repo"
cd "$projectsDir"/"$repo" && git am "$patchFile"
rm "$patchFile"

There are two variables of note: projectsDir and patchFile. patchFile is simply a temporary file where the script keeps the contents of the email. projectsDir is the directory in which the script will look to find your repositories. If you keep your repositories in a different location (e.g. $HOME/Projects) then you should edit this variable to point to that location.

Another important note is that the script looks for the repository using the text that follows the word “PATCH” in the subject. When sending emails with git send-email, you should specify the project name after the “PATCH” text so the person to which you are emailing the patch knows at a glance which repository your patch is for. If this is done correctly, a subject line will look something like:

Subject: [PATCH aerc] Fix whitespace in documentation

The script is licensed under the Unlicense, by the way.

After writing the script, I needed to add an Action in Claws Mail. This can be done through the top menu by navigating to “Configuration > Actions…” and creating an action to run a shell command. Prefixing the shell command with the pipe | symbol will tell Claws Mail to pipe the contents of the body of the email on which the action is invoked to the command. This is what my action looks like:

I also bound this action to a custom keyboard shortcut so I can press a key combination which will apply the patch. After running a shell command, Claws Mail helpfully opens up a window displaying the output of the command so I can see whether or not the command failed and what went wrong.

Here is an example of me applying a patch where you can first see a successfully applied patch, followed by what it looks like when the patch fails to apply:

So there you have it: a clean and easy way to apply git patches using Claws Mail. It’s even faster than using aerc too, since I only have to type a single keyboard shortcut instead of typing out whole commands.

Author: Jake Bauer | Published: 2021-08-18

If you’ve been a part of the computing industry in almost any aspect for a while, you’ll no doubt know about the trend of laptops becoming worse as time goes on. What used to be upgradable components became soldered, removable batteries became internalized and eventually glued in, and build quality decreased year over year. Nowadays, one seems to have two choices in the PC laptop market: buy a cheap, creaky mess of plastic with low-performance internals, or buy a possibly well-built yet overpriced laptop that may perform well, but does so at the cost of noise and usually battery life.

Frankly, the only ones offering a viable alternative to this mess is Apple.

Yep, you heard me right.

Apple used to be just as bad as the rest: you used to get an overheating, horrendously overpriced (a fully-specced 16” MacBook Pro would run you $4,000 USD!) laptop with a terrible keyboard, but with their M1 chip this has changed completely. You can now get a laptop that not only has outstanding build quality, all-day battery life, an excellent screen, a great keyboard, and desktop-level performance, but at half the price of comparable PC laptops while also being fanless.

If that hasn’t yet convinced you, keep reading.

Price to Performance

I think we can all agree that Macs had pretty terrible price to performance when they used Intel processors. Given that a 2020 base model MacBook Air was $999 USD yet had a CPU that fared not much better than my current Lenovo Thinkpad T420s in benchmarks and overheated so fast you couldn’t even get remotely close to its full performance… yeah, that was pretty bad. However, this has completely changed with the M1. Now we have a $999 laptop with performance comparable to many Ryzen desktop systems that sips power and, yes will heat up if you’re doing heavy tasks, but won’t take massive hits to performance just because it can’t handle the heat.

In the image above, the M1 is compared to the Ryzen 5 1600 (the same CPU I have in my desktop computer from 2017), and the Ryzen 5 3600X, Ryzen 5 5600X, and Ryzen 9 5950X. This benchmark clocks the M1 chip at being overall faster than the Ryzen 5 1600, and even still beating the Ryzen 9 5950X in single-core computations (though, of course, the 32 threads in the 5950X means it’s much better at multi-threaded stuff than the M1 with its 8). That means this mobile CPU which can fit in a fanless system and draws a meagre 15.1 Watts is more powerful than a 65 Watt TDP desktop CPU from 2017 and 2018 as well as competitive in single-core tasks with even recent Ryzen CPUs.

Further videos on the internet comparing performance such as this video from LTT and this video from Wolfgang’s Channel shows that, while the M1 trades blows with its AMD and Intel counterparts in some cases, it drastically outperforms almost all of the competition. For most of what I will be doing with the PC, the M1 Air absolutely blows my existing computers out of the water in terms of performance for less than the amount of money I spent on my desktop system in 2017 and in a—I can’t stress this enough—fanless laptop.

Build Quality and Keyboard

Macs tend to have excellent physical build quality. There is little to no flex of the chassis when typing on the keyboard, the screen doesn’t wobble when you adjust it or while you’re typing, and you can hold the laptop by a corner without creaking plastic noises. Since they switched to their Magic Keyboard™®© from their utter disaster the Butterfly Keyboard™®©, their keyboards also feel very nice to type on again and won’t spontaneously break from normal usage.

According to a friend of mine who switched from a Thinkpad X1 Carbon Gen. 6 to an M1 MacBook Air, the keyboard is miles better than not only that, but also Cherry MX switches. According to the aforementioned video from Wolfgang’s Channel, the keyboard is not as good as his Thinkpad X1 Carbon’s. So, while it does seem to be a matter of personal preference, if this keyboard is anything like their early 2010s MacBook keyboards (a keyboard I have actually used) then it will feel, to me, even better than my T420s keyboard.

Fanless Operation

I know I keep going on about how the Air is fanless, but that’s actually something I would really like to have in a laptop. My current T420s is hot and loud and it really shows it. Just sitting on the desktop, at idle, the CPU is at about 45°C with the fan audible. When I’m browsing the web, it easily spikes to 60% or 80% utilization, and it’s not uncommon for the CPU to hit 85°C and the fan to be going full-speed if I’m flipping back and forth between tabs or on any particularly heavy tabs (yes, I’ve cleaned out and re-pasted this computer… twice). This is such a problem that my laptop will overheat if I have it on my lap without wearing long pants (i.e. the bottom of the laptop is touching my legs) for an extended period of time and the amount of heat put out by this machine has even bothered people who sit next to me as I use my computer. Modern laptops might be better, but they’re still annoyingly noisy when doing anything intensive.

Having a fanless laptop will certainly be a luxury. When using my laptop on the couch or in bed, I won’t have to worry about whether or not the fans can breathe, I won’t have to worry about the fan noise of my laptop or the blast of heat shooting out the side annoying anybody near me, and I won’t have to worry about cleaning out the computer every two to three years just to keep it running well.

The Screen

Since Apple released their Retina™®© displays, they have been known for making stunningly good displays. They continue this trend with the M1 MacBooks by putting a 2560x1600 (that’s a 16:10 display ratio, much nicer than 16:9 for productivity), in a 13.3” screen for a wonderfully crisp 227 PPI. Not only will this be way better than my current 1600x900 display in a 14” screen, it will also be far better than the 1920x1080 displays one could normally get on competing laptops (without spending out a lot more money).

A good screen with sharp text is something I’ve wanted for a long time since using 4K 27” displays at work and since I read this blog post by Nikita on tonsky.me about better monitors. It makes a huge difference, especially for those who work primarily with text (me) in terms of comfort and clarity.

Battery Life

One thing that Apple has pretty much always been good at is jamming massive batteries into their laptops. If I had to guess based on pictures of internals, more than 50% of the internal space of a MacBook is taken up by batteries. This gives them battery lifetimes often much greater than competing laptops with similar performance. In the case of the M1, this is dialed up to the maximum because they combined their regular massive battery capacity with a chip that sips power. One can easily go a full day using their M1 MacBook without needing to charge their laptop. This is a huge upgrade from my Thinkpad which gets about 1 hour of battery life on a replacement battery purchased just one year ago (turns out that having a CPU that gets hit with regular near-100% utilization is not great for battery life).

MacOS

I know a lot of Linux and Windows users look at MacOS and think: “How could anybody use that!?” I know, I used to be one of them. At work when I got a Mac (a 2013 Mac Pro, to be precise) I was just endlessly frustrated at how MacOS felt. But, frankly, I just had a closed mind and wanted to hate it, so I did. Of course, a completely different operating system and desktop environment requires some effort to learn and get used to; exactly what we tell people switching over from Windows to Linux.

In reality, MacOS is a competent *nix system. It’s based on Darwin BSD, has zsh as a default shell with others also installed, has its own package manager homebrew, and has a perfectly competent terminal emulator. In reality, I can do everything I would want to do on my computer on MacOS without having to go through the hoops required on Windows.

Not to mention, my printer+scanner will actually work without endless fiddling or needing to reboot into Windows.

But It’s Apple!!!

Yeah, I know. Apple is not a good company. They are consistently against right to repair, lock down the upgradablilty and repairability of their products, and the majority of the operating system is proprietary (though, it’s worth noting that they’re still far better than Microsoft when it comes to their open source efforts, having made and released WebKit, CUPS, Bonjour, and more).

But this isn’t much different than most of the PC manufacturers. With many modern laptops you are quite limited in terms of what you can upgrade. For most, you can upgrade the SSD and the RAM and that’s about it. Many parts for discontinued laptops are also hard to come by or expensive, unless they were insanely popular.

It’s also worth noting that, in the case of the M1, you can’t upgrade the RAM because it is a system-on-chip (SoC) design similar to how the Pinebook and most ARM-based computers are built. However, that’s not really an issue since MacOS handles low memory conditions very well and I personally have no need for more than 16GB of RAM. I haven’t needed more than 16GB of RAM for half a decade and I don’t see that changing anytime soon given that I routinely use less than 4GB on my workstations.

Alternative Options

So, if I’m looking for a high quality, performant laptop for a good price then what are my other options in today’s market?

If I really want a fanless design I could either get a Chromebook or a Microsoft Surface. The Chromebooks universally suffer from terrible build quality or awful performance and the Surface laptops might be quite good (relatively speaking), but then I’m stuck with a product locked down by Microsoft and I much prefer MacOS to Windows. Surface computers also suffer from exactly the same repairability issues as Apple computers.

If I want something that does perform well and is well-built then I suppose I could go with a Dell XPS. They are “the MacBooks of the PCs” in terms of their build quality after all. But they’re also over twice the price as the M1 Air with worse performance and they can get very loud when doing intensive tasks like compiling software. If you’re thinking: “Why not get a Thinkpad,” it’s because modern Thinkpads have terrible build quality and are also monumentally more expensive than these new MacBooks for the performance you get. They suffer from the same problems as the XPS but aren’t even well-built.

Finally, in terms of a decent laptop that is repairable and upgradable, there is the new Framework laptop. While this does seem quite promising, it’s hot (it has an Intel processor) and doesn’t offer anywhere near the price to performance of these new MacBooks (once again, it has an Intel processor), though they are at least a strong competitor. The build quality, while decent, is also still lacking compared to Apple.

Summary

All in all, the pros of an M1 MacBook Air far outweigh the cons. Let’s go over them:

• Fanless - It’s silent and no need to worry about airflow or cleaning
• Excellent build quality - Not a plastic piece of e-waste (looking at you, Clevo chassis-resellers)
• Great battery life - Easily all-day battery life, even when using it intensively
• Good keyboard - Something that I’ll actually enjoy typing on when I’m away from home
• Outstanding Performance - Competitive with Ryzen 7 2700s in multi-core, and the latest Ryzen processors in single-core performance
• No T2 Chip - The M1 computers no longer have the annoying T2 chip, so other OSes could conceivably be installed in the future
• Unbeatable Price - Competing laptops are twice the price or more, for worse performance, build quality, noise, or a combination of those
• No Touchbar - I don’t like the touchbar, so I’m glad the Air doesn’t have it
• Thin as heck - It’s a laptop as powerful as a desktop, thinner than the screen on my T420s

And what about the cons:

• Apple - They’re a bad company, and it doesn’t make me feel good to buy something from them
• Non-replaceable SSD - The SSD could wear out and you can’t easily replace them which would render the computer useless, but this probably won’t matter in the lifetime of the device, since one would have to write terabytes of data to their SSD each day to even come close to wearing it out in a couple of years.

I’ve never owned a Mac (or any Apple product, for that matter). I currently own a T420s because I like the aesthetics and keyboards of old Thinkpads but, honestly, it’s just not cutting it anymore. A decade old computer is finally starting to show its age and it’s time for an upgrade. When nearly every other option on the market (including recent second-hand laptops) aside from the M1 Macs kinda suck, well, I’m going to choose the best option for the money I have and right now that looks like it’s the M1 MacBook Air.

Author: Jake Bauer | Published: 2021-08-05

Okay, so, Mastodon isn’t actually dead, but some recent happenings and a long-standing trend of the lead developer ignoring features beneficial to smaller instances have led many to start looking at other options, be it forks of Mastodon, or other software entirely. Recently, I and many others have taken a look at Misskey, an alternative Fediverse software that also uses ActivityPub and can communicate with both Pleroma and Mastodon instances.

What’s Going On With Mastodon (and Pleroma)

Recently, Eugen, the lead developer of Mastodon (also known as Gargron) released an official Mastodon iOS app which lacks basic features which many users deem important, especially for smaller communities. As of the time of writing, the app seems to intentionally be missing the ability to view the Local timeline (the timeline consisting of posts only from users of the instance you are on), and the Federated timeline (posts from all other instances which have federated with the one you are on). [Source]

This, plus the tendency for Gargron to deny useful patches such as Local-only posting and configurable character limits, has led to forks, such as glitch-soc, and the usage of other software, such as Pleroma.

For the time being, things seems to still be… okay. Mastodon is well-funded and nothing has yet changed for the desktop site or the software as a whole, but this could change at any moment depending on where Gargron wishes to take his software. This isn’t necessarily a bad thing depending on his goals for the software, but for those of us who want the Fediverse to be made up of a bunch of smaller, more community-focused instances as opposed to a set of large Twitter-like structures, the future doesn’t look hopeful.

Furthermore, Pleroma’s development funding has recently been cut, stagnating development and disappointing many users who were looking forward to exciting new features such as groups. There are… other issues with Pleroma, but I will not talk about them here.

Okay, So What Even Is Misskey?

To summarize, Misskey is another bit of Fediverse software, similar to Mastodon and Pleroma, but with far more features, and a far nicer and more polished-feeling UI. It is currently developed by one person, syuilo and is supported by a small amount of corporate funding, combined with some Patreon contributions.

At a glance, here are some of the features it has:

• Clips - basically public bookmarks
• Drive - view all media you’ve uploaded to the server, re-use images without having to re-upload them, and more
• Multiple UI modes built in to the front-end
• Federated chat
• MFM - Misskey-Flavoured Markdown, taking post markup to a whole new level
• Excellent admin panel features
• Custom timelines, channels, and groups
• Excellent UI customization

You may have heard of some trouble with Syuilo facing burnout and funding being cut. This is not untrue, but since Syuilo announced this, they have received some more funding, and have re-structured the way they develop the project. The project is far from dead, and with the recent boost in popularity, it could see development pick up again—hopefully in a healthier way this time.

How Is It From an Admin Perspective?

Having administrated Mastodon, Pleroma, and now Misskey for single-user instances, I can confidently say that Mastodon is the heaviest and Pleroma and Misskey are much lighter. Misskey is heavier than Pleroma, but not by terribly much; both are far lighter than Mastodon. There are also murmurings that Misskey scales better than Pleroma (which already scaled far better than Mastodon), though more insight is probably needed from the admins experienced with Pleroma.

Resource Usage

As far as my own servers: at this moment, the Pleroma server (Debian Buster) is using 685MB of RAM with a load average of 0.01 0.04 0.07 whereas the Misskey server (Debian Bullseye) is using 848MB of RAM with a load average of 0.35 0.18 0.15. Both are running on Vultr VPS instances.

Misskey tends to have more big bursts of CPU usage, so, in my experience, it is helpful to have more than one CPU core for your Misskey server. You also need to configure swap or have a minimum of 2GB of RAM to compile Misskey because it is a Nodejs project. You can probably get away with a $10/mo VPS from Vultr, DigitalOcean, or Linode for servers with a handful of people, but you will probably want to opt for the $20/mo VPSes for between 15 and 50 people. For example, @razzlom\@quietplace.xyz runs a Misskey instance with 50 users (approximately 10 active users) without ElasticSearch and they report that this uses 50-60% of 8GB of RAM and 1-10% of 4 AMD EPYC cores.

Admin Features

From what I and others have seen so far, the admin features of Misskey are amazing and the admin UI is much better than any other Fediverse software so far.

For example, you can see the size of various database tables, the server logs, the server resource usage, ALL media that has been uploaded to your server, and more from within the UI. Take a look:

Some other excellent features which are either missing from Mastodon, Pleroma, or both are:

• server-wide announcements,
• customizable post character limits (no more 1/X Mastodon threads!!),
• the ability to promote a post instance-wide,
• the ability to present advertisements to your users (assuming they are willing to accept that) which can help with funding your instance,
• the ability to easily monitor the job queue of the server,
• and the search does actually work well enough even without having ElasticSearch installed, and without needing to enable Postgres RUM indices like in Pleroma.

How Is It From a User Perspective?

In short, it’s unlike any other Fediverse software that currently exists. It is packed full of useful features and, even though some stuff can definitely be improved, it is exciting to see just what Fedi can be.

Timelines

With Misskey, you have the same sorts of timelines you expect from other Fediverse software. The table below summarizes which posts each timeline displays (note that “Home” post visibility is equivalent to “Unlisted” in other Fediverse software):

This behaviour is, in practice, slightly different than Mastodon, and quite different from Pleroma.

Health

Overall, Misskey seems to encourage more genuine social interaction compared to other Fediverse software and traditional social media. For example, there are no favourites on Misskey. You may see the “Favourite” option in the menu underneath a post, but this is simply a bookmark function. It is truly saving a post that you really like as opposed to behaving, in practice, as a meaningless “Like” button or read-receipt.

Instead, Misskey features emoji reactions to posts as the main way (aside from boosting) of interacting with posts. You can react to a post with a regular Unicode emoji (which other Fediverse software that supports this can see) or with custom emoji (which only Misskey users can see). This generally results in much more thought put into how you wish to react to a post, with “Favourites” from users of other software simply showing up as the thumbs up emoji.

Furthermore, the style of timeline that Misskey and Mastodon have tend to encourage more healthy interaction and consumption than Pleroma’s. Even though all social media is unhealthy to the degree that many of us use it, Pleroma’s timeline encouraged doomscrolling and negative interaction in a way that neither Mastodon’s nor Misskey’s do because it shows you absolutely everything that people you follow post which tends to drag you into threads that you really don’t involve you or need to involve you. I can personally attest to this, since I have been hosting and using Pleroma for over a year now.

Groups, Channels, Pages, Clips, Galleries, and Antennas—Oh My

This Misskey’s bread and butter in my eyes and what makes it stand out so strongly from the other ActivityPub-based software. There is a lot of fun to have with these features, though not all of them are federated just yet.

Groups are (currently) local-only collections of users to which you can send messages. Think of it like a group chat in applications like Telegram, Matrix, or channels like in IRC.

Channels are local-only posting groups to which you can post notes to only the specific people who are subscribed to that channel.

Pages are static pages on which you can put almost anything you want, including writing AiScript (a Misskey-specific scripting language) to add functionality to the page. Think of it a bit like GitHub Pages or something similar. You can then link these pages, and others can view them on your instance. Here is an example of a page.

Clips are like bookmarks but they can be organized and made public. Think of them a bit like Twitch or YouTube livestream clips, though text-focused instead.

Galleries are collections of public photos that others can see when they look at your gallery on your instance. The galleries themselves are not yet federated, so you do have to go to the person’s instance to see their gallery, but it provides an Instagram-like look at the media they’ve publicly uploaded and chosen to make available.

Antennas are possibly one of the coolest features. They are effectively custom timelines. You can make an antenna that just shows posts from specific users and notifies you when they post something new, you can make an antenna that collects posts containing or excluding certain key words, or you can make an antenna that collects only posts with files attached. If you want to emulate Pleroma’s timeline behaviour, you can even make an antenna consisting of “Notes from following users” with “Show replies” checked.

Your Drive

Your drive is possibly one of the single most useful features on Misskey. You are allocated a (configurable by the server admins) amount of storage space you can use for files uploaded to your drive and you can store whatever you’d like in there. If you want to upload a bunch of memes to have them easily on hand whenever you want to react to someone or if you want to simply re-share a file you shared before without having to re-upload it to the server or dig through your old posts, you can do that easily with the drive.

Apps

App support is a little limited at the moment. Since Misskey is not compatible with the Mastodon API, one can’t use apps like Tusky or Tootle with it. There are, however, a few apps available. Namely SocialHub for iOS and Milktea for Android.

One can also use Misskey in the browser, and it provides a reasonably snappy experience, but will most likely use more data than a dedicated app.

Other Various User Features

Some other excellent user-facing features which are either missing from Mastodon, Pleroma, or both are:

• an excellent threading model (similar to Reddit) where it’s much easier to follow the flow of a conversation,

• MFM (Misskey-Flavoured Markdown) which is like markdown on steroids and even supports LaTeX formatting,

• the ability to have custom CSS for your client, such as in the example below which makes it so that post parents are shown on hover only,

.tabs ~ * div[tabindex="-1"] {
    overflow: visible;
    contain: none;
}

.tabs ~ * div[tabindex="-1"] .reply-to {
    position: absolute;
    left: 2%;
    bottom: calc(100% - 1em);
    max-width: 85%;
    box-sizing: border-box;
    background: var(--panelHighlight);
    z-index: 1000;
    padding: 20px 24px;
    box-shadow: 0 .5em 2em rgba(0, 0, 0, .5);
    opacity: 0;
    visibility: hidden;
    transition: opacity .2s, visibility 0s ease .2s;
}

.tabs ~ * div[tabindex="-1"]:hover .reply-to {
    opacity: 1;
    visibility: visible;
    transition: opacity .2s ease .5s, visibility 0s ease .5s;
}

• working and federating pinned posts (which Pleroma lacks),
• good handling of posts that have been deleted (no more accidentally posting a reply to a deleted post, or needing to refresh to have that post disappear from your timeline!),
• automatically marking media as sensitive when you add a CW to your post (something every other bit of software except PleromaFE does, despite multiple requests to at least have the ability to do that),
• the option to auto-approve follow requests from people you follow,
• multiple different UI layouts built into the software,
• a relatively performant UI (as long as animations and blur are disabled),
• and an extremely customizable UI, with widgets!

The Rough Parts

On The Admin Side

Of course, not everything is without its caveats. For those used to Pleroma’s MRF system, Misskey doesn’t have anything like that. Admins can defederate from a domain and can silence and suspend individual users, but there are no options for a user to silence a whole instance themselves or for an admin to only strip media from an instance, for example.

On one hand, this does limit what moderators can do for their instance, but, on the other hand, if an instance really is causing enough trouble to bother your users and their moderators aren’t responding, just blocking them is probably what you’ll want in the end given that, more often than not, those kinds of instances just keep causing more and more trouble. It also keeps your options clear and simple.

One of the other downsides to administrating a Misskey instance at the moment is the lack of bulk emoji import support. Although it’s trivially easy to add, tag, and categorize emoji—even from remote instances—it is currently impossible to import a large amount at once. What you will probably want to do instead is go to your Drive, create some folders to organize your emoji, upload them all from your PC into the folders (you can upload more than one at a time), and then go to the Custom Emoji settings, choose import from Drive, and click on all of the emoji you wish to import.

This isn’t such a big deal if you only have maybe a couple hundred emoji at the most, but is more tedious than it could be. The same goes for categorizing and tagging those emoji.

Finally, there is currently an issue where Misskey has trouble federating with profiles that have bios which are too long. This has been fixed.

On The User Side

Currently, there are a few things which could be improved. For one, there is no option to limit streaming of new posts when you are scrolled to the top of your timeline. Unlike in Pleroma, where you can choose to have posts stream in as long as you are scrolled up or click a button when you are ready to see new posts, in Misskey this is not an option which can be frustrating as posts move down as you were reading them.

Another minor issue is that Antennas don’t show your own posts, unlike the other timelines. Although this isn’t a huge deal, many people like to see their posts as part of the conversation so it’s a bit weird to type a response and not see it appear in the custom timelines.

Also, mutes can be a little bit leaky. If you have a user muted, you can still see conversations involving them since it seems to only check post authors and doesn’t include mentions. A boost of a reply to a post of a user you have muted can also make it through the filter.

Finally, there are a few minor other UI issues such as notification dots getting stuck on (though you can hide them with custom CSS or mark all notifications read in the settings), some modals not being dismissable with the Esc shortcut key, and there is no option to play gifs or other media only when you hover over them.

Overall, these issues haven’t bothered me much and I consider them pretty minor compared to the benefits of Misskey, though your experience might differ.

In Conclusion

Although there are things yet unfinished with Misskey (as there is for all the other Fediverse software), it is already miles ahead of the rest of the Fediverse software I’ve tried. Yes, there are some rough edges and there might be UI elements or UX aspects that some don’t like or prefer, but at least for me, and for many others who have tried it over the past couple days, Misskey really seems like the future of the Fediverse; other software feels like it’s stuck in an old paradigm, trying to copy too much what Twitter or 4chan are.

Plus, since the seemingly overnight switch of so many users (at least in my circle) to Misskey, there has been a lot of work to figure out features, document things more thoroughly, and provide things like the aforementioned patch which fixes federation for people with long bios. Many of the issues I have with Misskey are minor and can be readily fixed.

If you check out Misskey and like it, please consider donating to Syuilo to keep development going. The future is bright for Misskey.

Author: Jake Bauer | Published: 2021-02-17

Having set up my mail server on OpenBSD, I’ve been very satisfied with the cohesiveness of the operating system; it has been a breeze to administrate. Since certbot just stopped working randomly on my previous server running Debian 10 and nginx, I took it as an opportunity to try out OpenBSD for hosting my website and reverse proxy. OpenBSD includes two daemons written by the OpenBSD developers—httpd and relayd—for just those purposes. They also provide acme-client as an alternative to certbot. All of this was done on OpenBSD 6.8.

Below is my httpd configuration. This contains configurations for renewing the TLS certificate as well as serving both www.paritybit.ca and ftp.paritybit.ca with redirects as needed. If I wanted to, I could also split these into separate config files and use the include directive.

types {
    include "/usr/share/misc/mime.types"
}

# For certificate renewal
server "paritybit.ca" {
    listen on * port 80
    location "/.well-known/acme-challenge/*" {
        root "/acme"
        request strip 2
    }
    location * {
        block return 302 "https://paritybit.ca$REQUEST_URI"
    }
}
server "paritybit.ca" {
    listen on * port 8080
    location * {
        block return 302 "https://www.paritybit.ca$REQUEST_URI"
    }
}

# WWW.PARITYBIT.CA
server "www.paritybit.ca" {
    listen on * port 8080
    root "/paritybit.ca"
    location "/" {
        request rewrite "/html/home.html"
    }
    location match "/.*%.html" {
        request rewrite "/html/$REQUEST_URI"
    }
    location match "/([^%.]+)$" {
        request rewrite "/html/%1.html"
    }
}

server "www.paritybit.ca" {
    listen on * port 80
    location * {
        block return 302 "https://www.paritybit.ca$REQUEST_URI"
    }
}

# FTP.PARITYBIT.CA
server "ftp.paritybit.ca" {
    listen on * port 8080
    root "/ftp.paritybit.ca"
    directory auto index
}

server "ftp.paritybit.ca" {
    listen on * port 80
    location * {
        block return 302 "https://ftp.paritybit.ca$REQUEST_URI"
    }
}

In the above configuration, there are two location match directives in the www.paritybit.ca server. The first matches any request for a path ending in .html and rewrites the request to serve the webpages from the html subdirectory as opposed to trying to find them in the root folder of the website.

The second matches any request which doesn’t have a file extension and appends .html to the requested resource path. This allows me to replicate nginx’s try_files command where one can tell it to search for files which look like $DOCUMENT_URI.html and it means that users don’t have to type out the .html extension when visiting a page on my site.

Below is my relayd configuration. I run multiple services from one IP so I need to reverse proxy incoming connections to various services on my network. As with nginx’s reverse proxying, relayd can handle the TLS connections to each of my services. I could also reverse proxy the connections to port 80 and redirect them using relayd, but I felt it was simpler to just let the webserver handle those directly.

The reverse proxy for Gemini at the bottom of the configuration is just for accessing it within my network because of my internal DNS configuration.

ext_addr = 10.0.0.20
table <pleroma> { 10.0.0.7 }
table <git> { 10.0.0.11 }
table <matrix> { 10.0.0.16 }
table <www> { 127.0.0.1 }
table <gemini> { 10.0.0.21 }

# TLS proxy all home services
http protocol "httpsproxy" {
    tcp {nodelay, sack, backlog 128}

    tls keypair "paritybit.ca"

    return error

    match header set "X-Client-IP" \
        value "$REMOTE_ADDR:$REMOTE_PORT"
    match header set "X-Forwarded-For" \
        value "$REMOTE_ADDR"
    match header set "X-Forwarded-By" \
        value "$SERVER_ADDR:$SERVER_PORT"

    match response header remove "Server"
    match response header set "X-Frame-Options" \
        value "SAMEORIGIN"
    match response header set "X-XSS-Protection" \
        value "1; mode=block"
    match response header set "X-Content-Type-Options" \
        value "nosniff"
    match response header set "Referrer-Policy" \
        value "strict-origin"
    match response header set "Content-Security-Policy" \
        value "default-src 'none'; \
        base-uri 'self'; \ form-action 'self' https://duckduckgo.com/; \
        img-src 'self' data: https:; \
        media-src 'self' https:; \
        style-src 'self' 'unsafe-inline'; \
        font-src 'self'; \
        script-src 'self' 'unsafe-inline'; \
        connect-src 'self' wss://pleroma.paritybit.ca; \
        upgrade-insecure-requests;"
    match response header set "Strict-Transport-Security" \
        value "max-age=31536000; includeSubDomains"
    match response header set "Permissions-Policy" \
        value "accelerometer=(none), camera=(none), \
        geolocation=(none), gyroscope=(none), \
        magnetometer=(none), microphone=(none), \
        payment=(none), usb=(none), \
        ambient-light-sensor=(none), autoplay=(none)"

    pass request quick header "Host" value "git.paritybit.ca" \
        forward to <git>
    pass request quick header "Host" value "matrix.paritybit.ca" \
        forward to <matrix>
    pass request quick header "Host" value "pleroma.paritybit.ca" \
        forward to <pleroma>
    pass request quick header "Host" value "ftp.paritybit.ca" \
        forward to <www>
    pass request quick header "Host" value "www.paritybit.ca" \
        forward to <www>
    pass request quick header "Host" value "paritybit.ca" \
        forward to <www>
    block
}

relay "reverseproxy" {
    listen on $ext_addr port 443 tls
    protocol httpsproxy
    forward to <git> port 80 check http "/" code 200
    forward to <matrix> port 8008 check http "/" code 302
    forward to <pleroma> port 8080 check http "/" code 400
    forward to <www> port 8080 check http "/" code 302
}

#For Matrix
http protocol "matrix" {
    tcp {nodelay, sack, backlog 128}

    tls keypair "paritybit.ca"

    return error

    match header set "X-Client-IP" \
        value "$REMOTE_ADDR:$REMOTE_PORT"
    match header set "X-Forwarded-For" \
        value "$REMOTE_ADDR"
    match header set "X-Forwarded-By" \
        value "$SERVER_ADDR:$SERVER_PORT"

    pass
}

relay "matrixrevprox" {
    listen on $ext_addr port 8448 tls
    protocol matrix
    forward to <matrix> port 8008 check tcp
}

relay gemini {
    listen on $ext_addr port 1965
    forward to <gemini> port 1965 check tcp
}

There is a lot of extra configuration for the HTTP services for setting things like Content Security Policy and other security headers (what a mess the Web has become…). I used the Pleroma installation guide for OpenBSD as a reference for the CSPs needed for that service.

As usual, the tools provided by the OpenBSD developers are a breeze to configure and administrate. Plus the comprehensive, accurate, and complete documentation provided with the system means that I don’t have to scour the internet for help only to find outdated tutorials or complicated documentation.

Author: Jake Bauer | Published: 2020-12-10

Last week I challenged myself to use a flip phone for one week straight. It turns out that it really wasn’t too hard to get rid of my Android phone and start exclusively using the flip phone. I’ve decided I’m going to keep using this flip phone as long as I can.

The experience has been great. Calling and texting is incredibly simple. I start pressing numbers on the keypad and the phone does the thing. I don’t have to unlock my phone, tap on an app, then tap on the little keypad button, then suffer the 500ms delay between pressing a number and having it show up on the screen. It’s the little annoyances which add up with modern technology that makes using relatively limited devices such as a flip phone feel just that much better.

I don’t use my phone at all outside of calling and texting now. I’ve totally freed myself from the burden of being always connected and (nearly) always available. When I turn off my computer that’s it; I am disconnected from everything but people who need to urgently call or text me. I also no longer wake up and check on everything while lying in bed for 20 minutes. I get up, get ready, then head to my computer. The same goes for falling asleep: when I’m in bed to sleep, I sleep. I don’t lie there for 20-30 minutes browsing things.

By the time I got to the end of the week, I had only used up ~1/2 of the phone’s charge. Part of it is indeed that I don’t use it nearly as much as I did my Android phone, but it’s nice to not have to charge my phone everyday or worry about it running out of battery by the end of the day.

The only drawback I can see to using this flip phone instead of a smartphone is that I won’t be able to listen to music or podcasts on the go when we all start having to commute again. It’s unfortunate, but I could always either get a portable music player or maybe bust out my cassette-based Walkman again. (Recording a podcast onto a cassette, then playing it on my commute… now that’s an idea.)

To sum it all up: I really honestly do not miss my Android phone. It was more a source of annoyance and distraction than a utility in my daily life. I feel more free and much happier using a phone that simply can’t do much but be a phone.

Author: Jake Bauer | Published: 2020-11-30

Recent frustration with my smartphone has led me to throw it aside (quite literally, I threw it onto my bed in frustration one day) in favour of using a good old flip phone again. I’ve challenged myself to use one for at least one week to see what the experience is like in 2020.

I normally carry with me an ASUS Zenfone II Laser Android smartphone running LineageOS 15.1. It has served me well over the past 5 years and its battery still lasts me a whole day… mostly. The things I normally do on my phone are: call, text, use a Web browser, use the Element, Conversations, and Husky applications, and check the weather if I’m bored. I sometimes listen to podcasts with it but I’ve stopped in recent months. I also have the OsmAnd~ map application, but GPS stopped working on my phone some time ago and I rarely, if ever, open it. I don’t even take pictures on my phone anymore thanks to some weird fogging that’s happened to the camera lens.

For this challenge, I’ve chosen a Doro PhoneEasy 612. Pretty much entirely because it’s what I had on hand. There’s nothing special about it, it’s a standard flip phone with a 12 key dial pad, some extra buttons, a 2 megapixel camera, a 2.5mm headphone jack (not 3.5mm), and it charges via Micro-USB like my existing Android phone. On the inside, it has a 3.7V, 800mAh (2.96Wh) battery, a mini-SIM card slot (though I was able to position my micro-SIM card just right to get it to work), and a microSD card slot.

After inserting my SIM card and powering on the phone, it asked me to go through a setup wizard so that I could set the date and time, ringtones, volume, and so on. After a couple of minutes, I was on the home screen with the world at my fingertips. By the way, this phone powers on in under three seconds (!!!) compared to the minute-and-a-half my Android phone takes.

This phone comes with a phonebook (which conveniently contained all of my contacts because I saved my contacts to my SIM card instead of my Android phone), messaging application, call log viewer, camera application, image viewer, alarm, organizer/calendar, calculator, FM radio (which only works if you plug in headphones), In Case of Emergency application (something that stores useful information about you in case of emergency), games (Tetris and something called Boxman), and a settings application. All-in-all very bare-bones but it does everything I think I need.

So, let’s see how this goes. One week using just a flip phone. I’ve even gone so far as to completely power off my Android phone and put it in a filing cabinet so I won’t even use it to browse memes in bed. I predict that this won’t be too difficult because we’re all stuck inside due to the pandemic, but it will still be interesting to see what it’s like, especially since I do compulsively use my phone before going to sleep and right after waking up.