January 2021 newsletter

Published: 2021-01-31
Word count: ~4380

Newsletter? More like snoozeletter. On this episode I get drunk, rant about software, and even get a rant in about hardware too. Yay.

Table of contents:

timtimestim

Fan works

Sometimes the internet is pretty Awesome. Not a lot of the time, but sometimes it is. One of those times is when people who like a thing get together to appreciate that thing. Otherwise known as "fandom". There's some shitty fandom out there, obviously, but that doesn't detract from the genuinely awesome and interesting manifestations of it.

This situation from the guy behind pinboard.com (a website that helps you manage your bookmarks. Which I can't imagine why you would need an entire website to do that, but whatevs'). Basically there was this website that people used to share their bookmarks of fanfictions. But the site went to shit because the founders of YouTube bought it for some insane reason, and all the users started to migrate over to pinboard.com instead.

(Seriously? Why would you store your bookmarks on a third party site? I don't get it?)

But pinboard is run by a single person who has at least a little sense in how to make a robust product, so his designs were extremely simple. But the fandom people wanted more complicated tags for their fanfiction bookmarks. So the guy who runs pinboard asked them to make a google doc of all the features that they thought were the most important in a bookmarking service. This is an actual product people pay for (why?), so it was in his best interest to cater to this audience that would more than quadruple his income.

In a serious feat of collaboration that could have only been fueled by the internet these people got together into this google doc and made it a beautiful work of effort, laying out in excruciating detail exactly what this guy needed to do to earn their collective business.

I know there's a lot of people out there that think all fandoms are horrible. I think there's some real stinkers out there, but for the most part I approve of fandom. These things make people happy. They make friends and beautiful art because of these things. They live in a small community of things that they can actually effect. They make their own cultures and rules and carve out a little corner of existence for themselves.

This pinboard story is a great example of the sheer scale of fandom. Just how many people out there care about the art they love. I am constantly blown away by the sheer love that these people show these things. You can't get people to cooperate normally, but if you give them a common cause and a common love, maybe that's enough for minor things like helping a bookmarking service.

I'm a little biased, since a lot of my reading, especially in my teenage years, has been fanfiction. I subsisted off fanfiction for quite some time, until I only recently re-developed a taste for classic works. There are some genuinely amazing fanfiction stories out there, and it's a shame that it's seen to be so low status to admit it.

I've seen so many fan works, not just words, but pictures and comics and videos and everything. And it makes me so happy that people love something so much that they actually want to express themselves creatively using that thing. There's something beautiful in fan works that gives me that warm fuzzy feeling. Even if most of it is porn.

And there's the "fuck copyright" perspective. I won't belabor the point, but I see fandom as an example of how copyright is mostly restrictive on a broad cultural scale.

This was a fun story. Just... Why would you ever use a web service for your bookmarks? Wouldn't it be nearly as useful to just have a list of links in a file on your desktop? Maybe put a tag on the same line so you can CTRL-F for a link later? If you want something crazier you can use a bookmarking tool that's local to your computer so you don't have to worry about it being bought out by some posers and broken before your eyes? Bonus points for open standards.

See also: This blog post about the technical aspects of dealing with the rush of people.

Virtue Points

I'm very interested in how to be more productive. I think a lot of people are. Maybe there's some universal fetish for competency, and we all want to reach an ideal we can't always reach.

Either way, I sometimes come across an idea that's interesting, but that I wouldn't actually want to implement myself. This month's absurd thing was virtue points from Eric Neyman.

The idea is simple. You set yourself a "virtue point" goal for the week, and you do things that you care about to reach said goal. So if you write for 2 hours you get X points. If you exercise for 20 minutes you get Y points. You do thing A to get B points.

The most important part of this system, and the reason I think it's rather brilliant, is that you can also earn virtue points by donating to charity. You might think that this is a terrible idea because you could just donate to charity to weasel out of anything you don't want to do. And then you realize that you're donating to charity.

If you're at the end of your week and you need to reach the virtue point goal, you can top it up with a donation. There's less pressure to do low-quality work, since you know you always have an out that aligns with your values if you slip up.

I would say it's up to you to set the numbers. The ratio between how many points you get for things versus your points goal versus how much you get is a personal decision.

There's also the issue of incentivizing yourself to want the virtue points in the first place. The author of the article uses a website called "beeminder", where you track a goal and pay money if you fail to meet it. I'm sure a motivated person could find some other way to guide themselves along if they wanted.

Sadly, this kind of system isn't good for my own specific brain. I've tried many time to do similar setups, and they always end with me being angry and depressed at myself. I find that I get far far more work done when I just allow myself to work at a natural pace instead of trying to force incentives that I know are manufactured. My subconscious mind sees straight through the trick, no matter what.

But I wanted to write about it anyways, because this kind of out of the box thinking is the kind of thing that I like to read about. Sometimes an idea that doesn't work for you might someday be a puzzle piece you need for an idea that does.

For other ideas see:

i3wm dies on the bathroom floor, floundering like a gutted fish

Okay this section title is totally lying, but the image came to my mind and my fingers typed it out and there was nothing I could do. Sometimes my brain needs a thing to exist, and this time it needed to call attention to a window manager doing a good thing by pretending it's doing a bad thing. I don't have any control anymore.

What the fuck am I talking about? I'm glad you asked. i3wm is the software that I use to manage my windows on my Linux computers. In the Linux world you can choose to have your windows work in any way you want, and the one I choose is the way i3 does it. I choose to use it because it strikes a nice balance between simplicity, power, and usefulness. I only use a small fraction of the total potential of i3, but about 1% of the time I'm extremely glad that I have that extra bit of power.

It's also the window manager that I've made my perfect dream setup in, and I don't see any reason to switch to something else. Especially given the news that I heard this month.

Basically the i3 dev team have decided that they're not going to add new features to the software that they're making, and instead are going to focus on making it robust and reliable.

The idea of "finishing" software is a strange one. It's expected and accepted broadly that software has to constantly acquire more features the longer it exists, or it's "dead" or not worthwhile. I find this to be extremely strange. You finish making a movie, you finish making a piece of art, a book, a woodworking project, or even macaroni art. Software isn't so unique that you can never have a completed useful product.

So when I heard that the i3 devs were finished adding complexity to their project, they immediately earned my respect. Here's a popular window manager (relative to other window managers) that has shifted their focus from "adding features" to "making sure existing features work as well as possible".

They aren't totally disallowing new features. They're basically saying that they're raising their standards for how useful a new feature needs to be before they add it.

Can you imagine if more software projects did this? That after a few years of working on them they solidify their feature set and focus mainly on fixing bugs and making the software more robust? Can you imagine how reliable software would be, if that were the case?

I very very much approve of the i3 dev team on their decision on this. It's increased my confidence in using their window manager quite a bit, since I know that it isn't going to grow in complexity past the point where I can accept it, like so many other things that I've used in the past. Instead it will sit there in the exact spot between "too much" and "just enough" that I like it to be in. The features that I use will only get more reliable as time goes on, until the project is basically "done" and we don't need to worry about it again. Having a constant like that is a nice feeling.

This is similar to the kind of thought process I have for my own software. At least the serious stuff. Once I release the v1.0 update, that's it. That's what the software is. I cultivate a paranoia about adding new features after that, and an even stronger paranoia about breaking backwards compatibility. For example, my program jornal is "complete", even though I've since thought of some ways I could have improved the file format and the functioning of the tool on the command line. Keeping the tool reliable and robust is far more important to me, even when I'm the only person who actually uses it.

Bravo to the i3 team for having some fucking discipline.

Tim complains about web browsers again

There are two piece of software that I use the most on my laptop: A terminal emulator, and a web browser.

(Let's not even fuck around with mobile phone software. Otherwise this shit will go on for days, and I have other things I want to write.)

My terminal emulator is st, a shockingly simple program coming in a just about 3800 significant lines of code by my own count. It is robust, stable, effective, and battle tested to the brink of insanity. It does exactly what I want it to do, and I feel like I can rely on it. I use this program in one way or another every singe day for hours.

My web browser is Mozilla Firefox, a shockingly bloated program coming in at 21 million lines of code according to this post. It is flaky, insecure, slow, hard to use, and receives regular updates that don't actually do anything useful. I use it because it's the only reasonable way to deal with the internet, not because it's a good choice for my values. I use this program in one way or another every single day for hours.

How could this happen? Where did we go wrong? Drew DeVault offers a plausable explination in his article, The reckless, infinite scope of web browsers.

In this article DeVault counts words. Specifically, he counts how many words are in the "W3C specifications", which are the technical documents explaining how the world wide web works. The count comes out to being about 114 million words long, after an enormous underestimation.

Now, I'm a writer. I write a lot of things. So I feel like I'm in a position to intuitively feel the weight of 114 million lines more than the average joe.

To put it in perspective, I could write at a ridiculous pace of 2 million words a year and I would only just barely reach that number if I'm lucky enough to be able to maintain it for 60 years. That's just not going to happen. Period.

And this is dense technical documentation, not prose that I'm writing for the sake of filler. If it's a massive issue to write so much, it's an order of magnitude worse to read it all and apply it into a working implementation of a web browser.

I think quoting directly from DeVault here would be good:

The complexity of the web is obscene.

"Obscene" is a good word for it. It's grotesque to look at. It's grotesque to think about. It's impossible to improve upon. And it's growing like a tumor.

Web browsers are the absolute rock bottom worse failures of the software industry. For their impact, for their standards, and for their horrifying cancerous growth. The only way to interact with the web is to use a web browser, and that's... really bad.

God help us as we continue to build on this foundation of wet sand.

Status == diarrheoa

This post from Robin Hanson on OvercomingBias is old. It's exploded from link rot. Still, it talks about the power of signaling.

I'm not a cognitive scientist, so I recommend you look around for better explanations of what's going on in this article. If you're into feeling despair about the human race, that is.

The Xi Editor was doomed to fail

I read the retrospective of the "Xi editor", which is a text editor that was supposedly made with the intent of lasting for the "next 20 years". It lasted 4 years of development hell before they gave up on it, instead.

(Author's note: I'm kind of drunk while I write this section. Prepare your body.)

  1. Async design with... JSON as an inter-process communication format??

What. The. Fuck. Were. They. Thinking?

"Hey I want to make a robust piece of software that everyone should use as a base for their own forks!" and "Hey I want to use JSON as an inter-process communication format" shouldn't even be in the same lexicon of each other. And yet here we are, apparently surprised that this decision backfired. Huh?

First off, async design. Really? Really really? A text editor? I get that using the multiple cores on a CPU is a good thing that makes things go fast, but you do realize that text editors have been fast since the stone ages of computers, right? It's not like you're running a complicated simulation, or a videogame, or anything actually intense for a computer.

Here's a good piece of advice: If you want your software to be easily understandable (which, I hear, is a good idea if you want it to exist for a long time), you probably don't want to add the exponential complexity that a fully async design would add. Your first instinct, in every instance, should be to do everything on a single thread unless absolutely necessary.

But no. You decided that your holy grail lingua franca of text editors was going to have a complicated, hard to integrate, async design. And you wonder why nobody adopted it? Ugh.

But that pales in comparison to the choice of using JSON as a inter-process communication format.

Here's a good piece of advice: Your communication format should be simple enough that a novice programmer can make good use of it within a week of trial and error. And I'm talking like "just came out of the womb" novice, here.

Why. WHY would you choose a format that's so damn complex for something like this? JSON is like XML, in the sense that people use it in places it doesn't belong because they can't be bothered to do something simple.

Every single communication format and file format you use in your program is another dependency. To put a dependency on such a baroque file format is basically spitting in the face of anyone who wants to use your system. I can't imagine what was going through their heads when they decided this.

  1. Fucking rope data structure.

Okay, so they say that the rope data structure works well for them, and that it was one of the successful parts of the Xi project. That's great for them, but also fuck off.

Let me be abundantly clear. The more complex your project is, the less amount of time it will last into the future. Unless you build up significant network effects and have a massive team working around your deficiencies, like HTML and JSON and XML and the internet, you will fade into nothingness as soon as your potential heirs (the future developers who will take over the project) can't understand your program.

So this becomes a tradeoff. Do you use a complicated data structure for your program, or do you stick with something more simple to understand, but less efficient?

In this case they've made the wrong decision. And they even congratulated themselves for doing it.

The "gap buffer" data structure is far easier to understand when it comes to text editors. And unless you're something like Vim or Emacs, you're not going to have enough developers interested in you to do something as complicated as rope in the long term.

The best way to figure out where you need a complex data structure is to start off using the simple thing, and only escalating the complexity after you've seen a need to do so. They, of course, chose a rope data structure off the bat. They chose the most complex thing possible that would still work without even seeing if they needed it!

Fuck you, I won't explain the difference between rope and gap buffers. Look them up on wikipedia. Jesus I drank a lot of fireball. Whiskey is fun, especially when you're writing.

Anyways, they say that Rust -- their programming language of choice for this disaster -- wasn't good at doing gap buffers. Bullshit. If that's actually true (a hard pill to swallow), rust wouldn't be anything more than a toy language. A gap buffer is literally just two stack memory buffers that get pushed and popped to simultaneously. If your systems programming language can't do that with a couple functions and little pain, then what the hell are you even doing? Is this real life? You're telling me rust is bad at doing gap buffers?

  1. Rust.

You can make good fast things in rust. Just look at ripgrep for an example. But if you're trying to make software that will last a long time, are you really making the best decision with rust?

Just use C. C has compilers out the ass. C has support for everything. Any language, from python to Rust, can call C code. Because C code is universal. If you want your thing to last a super long time, use C.

But that's not really the problem, is it? No the problem is that they didn't make it into a library. They decided to make it into a fucking async application that you had to communicate with using fucking JSON, and they didn't come up with the obvious idea of just having a text editor library that people could use and extend however they wanted.

Their choice of rust is awful, not because rust is a bad language, but because it's not the right choice given their goal of longevity. They fell for the memes, and ignored the obvious path forward of making a C library. God damn.

  1. Not even fucking trying.

They didn't have a vi mode for their reference implementation. They wanted to make the text editor to end all text editors, and they didn't even have the single most pervasive text editor style built into it.

Not having a vi mode is like... Like someone making a bridge that doesn't allow long road truckers to pass through. It doesn't even make sense. Vi/Vim/Neovim users are something like 80% of the obscure nerd editor market. That's a highly specific number that I totally didn't just pull out of my ass.

  1. Fuck all y'all.

In short, I believe that they were hoping the editor would last the "next 20 years" due to attracting enough people though using trendy things, instead of actually thinking through the problem of making robust software. The "grow exponentially or fail" strategy that a lot of venture capital businesses use.

Software like Vim exists because the amount of people using it is able to prop it up, even given its atrocious source code. I figured that they were trying for the same thing with Xi. Or they didn't have an actual plan at all, which seems even worse. Did anyone actually think about this?

Given their decisions, I'm not surprised that this piece of software crumpled under the weight of it's own complexity.

Im drunk. Im going to stew in my own inebriation until I pass out. Drunk Tim out.

DALL-E

Open-AI is back at it again with that AI boi. Oh shit waddup.

Seriously, though, DALL-E is crazy to me. Like, what the fuck? I'm noticing actual creativity in these pictures it generates, and in a medium that's far more "noisy" than simple text completion.

Imagine what AI will look like 10 years into the future. Imagine 5 years, at the pace we're seeing right now. Oh my god.

Earbud Update

In October of last year I got new earbuds. They were nice, expensive, and I got them specifically because I didn't want my earbuds to break 3 months after buying them.

And guess what? In less than three months they broke. So, fuck KZ ZS10 PRO's. Fuck you KZ. Fuck everything.

I put my earbuds through a lot of pain. I wear them all day at work, put them in my pocket all the time, and generally abuse them. But buying a $50 pair should have let them last for longer than three months! That's the same amount of time the shitty skullcandy earbuds I get at Walmart last, for fucks sake.

And before you're like "It's the wire that broke lolol!" I can assure you that you're full of shit. My life is an endless cyclone of incompetence causing minor annoyances that I blow out of proportion. The ZS 10 PRO's are detachable from the wires, so I tested the broken bud on a new wire and it still didn't work, while the other factional bud worked just fine on the wire that the broken bud was sitting on.

I just want to have things that are reliable. I'm willing to pay a lot of money for this privlage. And yet it's still bullshit. My audiophile friend tells me that there's no earbud on Earth that can actually last under the conditions I use them under, which is just lovely. Real good job music industry. Fuck you.

Dumping ground

Read later