gay robot noises - /var/log/ash

Obligatory AI Opinions Post

2026-02-24T00:00:00+00:00

This is a post about how I personally use AI. This is not a post about the ethical/societal/environmental issues. This is not because I do not think there are any, but because I do not wish to talk about them in this post. This is also not necessarily a judgment of other people's usage; these are my personal preferences. Conversely, do not read this post to imply that I condemn or commend things that I do not mention. That being said.

personal software projects</h3>
No usage for code. I don't have any personal projects that I want badly enough to overcome my dissatisfaction with the feeling of non-understanding that using an agent would give me. I avoidusing big frameworks for the same reason, a lot of the time; e.g. in my React projects I never used create-react-app. This is also one of my biggest complains about Nix as infrastructure, and why I tend to like the "assemble your desktop environment" model of Linux systems as opposed to more "batteries included" ones like KDE or Dank.
I would consider using a local model (we have some pretty decent hardware at my apartment), or possibly an open-weight one run remotely, if I had any large scale automated refactors to do. But I don't.
I do, however, use the free Claude model for things like coming up with names or "give me some ideas for how to structure this". For my current project, I asked it how to have a Nix package with a Rust frontend and a TypeScript backend with the compiled JS embedded into the binary, but served separately during dev time, and the technique it gave me basically just worked. And now that technique is in my personal repertoire, and in my notes.

personal writing</h3>
None. It violates the purpose. I would possibly consider passing it through a spellchecker/grammar checker solely for the purpose of catching unambiguous errors (as opposed to stylistic choices).
An observant observer may notice that the diction of this post is quite different than my usual. This is an intentional choice, although the reasons for that choice are somewhat opaque to myself. It is, in any case, not a signifier of a difference in process.

professional software projects</h3>
This is where the "large scale refactors" from above comes in. I've thrown agents at tasks that are not amenable to AST-based manipulation, such as "in this folder, find all functions that pass in a Foo, Bar, Baz, and remove the Foo and Bar parameters, accessing those values from the Baz instead; fix all callsites.". This is not a productive use of my time to manually do, and doing this makes the interesting work easier. I've also used it to quickly check whether a couple ideas were viable, generating maybe 100-200 lines of code each time.
In all cases I manually reviewed the code and would consider myself fully responsible for any breakage as if I had typed it myself, of course.
I would not use these models for building out nontrivial larger projects because I believe that skill would atrophy, and because reviewing code is always less pleasant than writing it.
professional writing</h3>
Very little. I've passed documentation through an LLM for clarity (since my personal desire for style is somewhat out weighted by professionalism here, but only somewhat). I wouldn't use it when talking with people. I also once had a longer document run through an LLM against my wishes, which annoyed me, but I didn't find fighting it to be a good use of my time.
personal image generation</h3>
I have used it for generating a couple avatars as self-representation, typically with a 1-2 hour amount of "effort" each time (including time spent in an image editor doing manual postprocessing) with a 50% duty cycle: roughly half the time was spent waiting for generation. This was with a local model several years ago, so if I did this again I would likely spend much less time waiting. I've also considered using a local model for generating computer wallpapers. I've used "corporate" models for quick "I want a quick visualization of this character doing this thing" images, none of which left the context of a Discord DM or similar.
I am intentionally not addressing whether or not any of this counts as 'art'.
socialization</h3>
I have talked with Claude on one occasion about a particular mental hangup I had been bothered by for quite some time. The advice I received was useful, and at least partly driven by the process of speaking the anxiety, in the same style as rubber-duck debugging or tarot. I would not tell a non-local model anything I would not feel comfortable in a training set, and anything "severe" I would not consider a local model to be sufficient for.
I find the idea of constructing a "personality" that a persistent model would inhabit to be interesting, but I would require local control, and I suspect that there is a nonzero chance I would develop some kind of emotional attachment in excess of what I would consider healthy. So I haven't experimented with this.
conclusion</h3>
AI is a land of contrasts.

An actually useful definition of 'slop'

2026-01-20T00:00:00+00:00

If you have a functioning Internet connection, you've probably seen someone use the word "slop" to refer to something they don't like, especially if that something was produced by AI. I don't think this is useful. Arguing about definitions of fuzzy terms is inherently a fuzzy endeavor because by definition (heh) I can't be wrong about what other people mean by a term. So to be clear: my definition of 'slop' isn't "this is what other people mean by the term", it's "this is a definition that I think results in useful analysis".

'AI' vs 'machine learning'</summary>
I don't think it's worth trying to say that LLMs aren't "real AI", because this doesn't align with my own experience with what was considered "AI" when I was working on related projects over a decade ago and because it strikes me as the equivalent of trying to distinguish between "computers" (which are good) vs. "automated arithmetic" (which is bad). But that's its own post. </details>
With that out of the way, my definition is:

Slop is something that has all the surface value of high-effort production, but is actually extremely shallow and not thought-out. </blockquote>
It doesn't matter how much of the thing was made by humans and how much was made by a generative AI model. Slop is slop.
Not all slop is AI</h2>
One of my motivating examples for this is actually a satire, but it's so well-executed that it's perfect as an exemplar: </video>
This video (Youtube original</a> by Funkyzeit Games, with voice acting</a> by RyanStewartVO and ArielHck) is parodying a specific trend in video games, but even if you aren't much for games yourself, there's a lot of things that stand out:

The video is voice acted (which is pretty nontrivially expensive in a game), but all the dialog is generic and bland.</li>
The lighting is very "realistic", with lots of bloom, ambient fog, dynamic lighting, and dynamic reflections; but Mario and the Goombas still have plain flat textures; contrast this with Mario in Super Smash Brothers Ultimate</a>, where you can see the fabric of his clothes if you zoom in enough.</li>
There's no Mario in the Mario. The Fire Flower pickup at 0:24 could have been from any game with a vaguely red-themed powerup.</li> </ul> It's a perfect example of Nintendo, Hire This Man</a> game development. It's slop (or it would be if it was serious). And it's all human generated. Anyone that looks at a lot of digital art (especially anime-style) will be familiar with the sort of images that tend to get popular: very "rendered" (i.e., detailed with effort put into lighting), often focusing on attractive women, but very little individuality. If it's fanart, there will be emphasis on visual signifiers and a deemphasis of the character's personality.
SEO spam is also one of the quintessential examples of human-written slop; although a lot of the pre-LLM SEO spam was certainly generated using mechanical assistance (thesauruses to rephrase content copied from other sites, fill-in-the-blank templates, and so on), the bulk of it still involved a lot of humans who were presumably paid poor wages to do it. It was/is meant to trick you into thinking that the content is worthwhile so you would click around, get ad impressions, and make the creator(s) money.
Not all AI is slop</h2>
Back before Stable Diffusion and NovelAI and DALL-E, there was DeepDream</a>: broadly, you take an image model designed to recognize something (in this case, probably dogs), take an image (in this case, the Mona Lisa), and iteratively adjust the image to maximize how 'dog-like' it is. This image looks like a weird fucked-up experimental piece of generative computer art, and that's exactly what it is. A lot of early generative images had this quality, and a lot of early generative text did as well (going back all the way to Markov chains like the dissociated press</a>). </video>
Similarly, look at the video for Make Me Feel by the Chainsmokers. The video here clearly also makes heavy use of AI image generation using a human dancer (whose face you can occasionally see "breaking through") as a base, with almost no "cohesion" between frames and very little attempt to ensure that the generated images are at all coherent. But the video is good! It's using the weird "morphing" of non-temporally-coherent video generation as an an effect like a very fancy image/video filter. You don't necessarily have to like the video or the music (I personally like both), but you do have to acknowledge that there's some very human intentionality going on here. I'm sure someone more conversant in the history of videos and effects could draw all kinds of historical comparisons, but the only comparison that comes to mind for me is the scramble suits from A Scanner Darkly</a>.
And finally, you have shitposts like "Steve Harvey being chased by a horror movie monster trailcam footage" (source unknown). There's no pretense here. It's just something that someone thought would be funny, typed into the funny image machine, and shared with their friends. For that matter, the low-quality of it is almost the point: it's the sort of throwaway shitpost content that's the equivalent of shoving something into an image editor, writing "TFW WHEN YOU / BOTTOM TEXT" without even setting the text tool's background to transparent, pasting it directly into a #memes</code> channel on Discord, and getting two reacts. I'm not trying to argue that this is the aboslute peak of humor or that the novelty of any particular genre of AI-generated image won't burn through in roughly 30 seconds, just that I don't think there's much you can say about the effects of this kind of image that's also true of overly-polished Github projects with fancy HTML landing pages that fall apart as soon as you poke under the covers.
So what do we get out of this definition? The big one is that we can see that slop has been with us since before generative AI models, but the cost to produce slop has changed drastically. Writing "decent-looking" SEO bait is far easier than learning to draw "front page of artstation" images, but generative models can handle the latter just as well as the former. And the flip side is that even if we were to somehow ban generative AI models, we wouldn't fix the slop problem. Google search's slow slide in quality started in the mid 2010s at the latest, well before generative text models were widespread enough and cheap enough to be blamed. If we want to stop the slop problem, we'll have to change the incentives. Figuring out how to do that is out of scope and therefore left as an exercise for the reader. I know this post is just me typing into the void; I'm not under any illusions that I'm about to singlehandedly reform all of discourse online. And there's no way to know that anyone using "slop" is or is meaning it in a certain way. But I hope that at least thinking about this particular meaning will prevent you from falling into thoughtterminatingclicheslop.
I am tired of the word 'techbro' 2025-06-22T00:00:00+00:00 The word 'techbro' has seen a massive uptake in the past few years (source: trust me), driven in large part by the massive hype machine that is the AI industry. I don't think it's a useful word, I think it's used to imply connections that don't exist, and I think we'd be better off without it. To illustrate my point, here are three people I've seen referred to as "techbros": Richard Stallman</li> Eliezer Yudkowsky</li> Sam Altman</li> </ul> In terms of their beliefs about technology, they're all fairly different. I don't know offhand what Stallman thinks about AI, but given all of his other stances I think it's a safe bet he's very against the OpenAI model of "run everything on the cloud server and trust the vendor". Yudkowsky and Altman both talk about the transformative power of AI, but the former views it as a massive threat and the latter phrases it as a massive advancement for humanity. Altman is incredibly rich, but Stallman and Yudkowsky aren't. Wiktionary defines the word "techbro"</a> as: (slang, typically derogatory) A bro</a> (someone who espouses bro culture</a>) involved in the tech industry. </blockquote> but I certainly wouldn't put Stallman or Yudkowsky in the realm of 'bro culture'! (I don't know what Altman's like.) The phenomenon described here is much more an artifact of the early 2010s, the era of Klout's infamous "bro down and crush code" recruiting partner or CouchDB's "perform like a pr0n star" talk. Note that in both of these cases, the behavior being critized is very directly linked to "bro culture"! So, the three techbro figures, what do they have in common? They're strongly associated with computers. Note that it's not necessary for them to actually have any knowledge of tech themselves; Peter Thiel is often called a 'techbro' even though as far as I'm aware he doesn't really know how to program.</li> They're men. 'Bro' is, of course, a highly gendered term. I have yet to see anyone call anyone "techsis" unironically; people generally either drop the phrasing entirely in favor of more specific descriptions, or result to painful circumlocutions like "techbro-coded behavior". There are going to be women involved in AI; I'm certainly not a booster, but I'm much more neutral on it than many of the people I know who use the word 'techbro', and I know several women who use generative AI in their personal artistic projects as well as women who work at generative AI companies. If your go-to insult here is 'techbro' then this puts you in an awkward spot.</li> They're disliked by the sort of person that calls people 'techbros'.</li> </ul> As far as I can tell, that's really the content of the term: a techbro is a man associated with computers that the speaker dislikes. I don't mean to sound like I think every insult must be the peak of intellectual rigor; there are many different ways for someone to be a "shithead". And there are many other terms in ordinary use, like "chair" and "game", that don't really have a very rigorous definitionion; instead, they're defined more by a family resemblance</a>. But by the same token, it would be very difficult to use "chair", "game", or "shithead" as a term of analysis in a productive manner. postscript</h2> While looking things up for this article I found this Wired article from 2010</a> making basically the same argument I am here. Ah well. Type-level Bounded Recursion in Rust 2025-05-25T00:00:00+00:00 Blowing the stack is one of the few ways to kill a Rust program that you can't really recover from. On Unix systems, the area just past the end of the stack is set up as a guard page</a> (either by the host OS or by Rust's own setup code) so that trying to access it will trigger a SIGSEGV</code> or SIGBUS</code> signal, and as part of the general setup code Rust adds to every program, it installs a signal handler that checks if the address that caused the signal is a guard page, and if so, aborts your entire program. The code for setting it up</a> is straightforward (and has some fun SAFETY</code> comments too). The reason that this is an abort (which you can't catch and always causes program exit) as opposed to a panic is because it's effectively impossible to guarantee anything about the state of the world. In particular, you might be in the middle of executing some unsafe</code> code, an FFI handler, or some other thing where allowing execution to continue would violate safety guarantees. Plus, when the signal handler returns, you're still out of stack space, so you'd have to unwind without allocating any more stack! Even backtrace-on-stack-overflow</a>, which does what the name implies, aborts immediately after printing the backtrace and comes with a note saying that it's "unsuited for being enabled in production". Languages with a runtime (Java, Python, Go, Javascript) can just have the runtime manually check the stack, but we don't have that. The simplest answer is to have a depth</code> counter and decrement it on every recursive call: #[test] fn recursive() { fn sum(depth: usize, xs: &[u64]) -> Option<u64> { if xs.is_empty() { return Some(0) } if depth == 0 { return None } Some(xs[0] + sum(depth - 1, &xs[1..])?) } assert_eq!(sum(2, &[3, 4]), Some(7)); assert_eq!(sum(0, &[3, 4]), None); }</code></pre> Easy, simple, and basically what I wound up doing when I ran into this problem. But you don't need a blog post to tell you how to pass a parameter, and I wanted to show off. So let's have some fun with it. If we're going to make this into something reusable, let's define some helpers. For reasons that will become apparent shortly, we define the natural numbers using the standard Peano encoding</a>: enum Nat { Z, S(Box<Nat>) }</code></pre> and implement a helper function that automates the recursion: impl Nat { fn recurse<In, Out>(self, mut f: impl FnMut(Nat, In) -> Option<Out>, val: In) -> Option<Out> { match self { Nat::Z => None, Nat::S(nat) => f(*nat, val) } } }</code></pre> We can see that this produces the behavior we want by writing a test sum function: #[test] fn nat_to_usize() { fn sum(depth: Nat, xs: &[u64]) -> Option<u64> { if xs.is_empty() { Some(0) } else { Some(xs[0] + depth.recurse(sum, &xs[1..])?) } } let nat1 = Nat::S(Box::new(Nat::Z)); let nat2 = Nat::S(Box::new(Nat::S(Box::new(Nat::Z)))); assert_eq!(sum(nat2, &[3, 4]), Some(7)); assert_eq!(sum(nat1, &[3, 4]), None); }</code></pre> But this still has the problem that we have to actually pass around an entire parameter. We should be able to do better than that. And here's where the bullshit begins. First, we repeat our definition of the naturals, but at the type level: use std::phantom::PhantomData; struct Z; struct S<N: Nat> { _phantom: std::marker::PhantomData<N> } trait Nat { // ... to be filled in! }</code></pre> Implementing the type-level version of Nat::recurse</code> is trickier, because there's no way to express a type that requires a function to have a generic parameter, let alone require that generic parameter to be constrained by a trait. So we emulate it using another trait: trait TakesNat { type In; type Out; fn call<N: Nat>(&mut self, arg: Self::In) -> Option<Self::Out>; }</code></pre> Note that we don't actually need to pass in a value of type N</code> here. With that definition in hand, we can fill in our Nat</code> trait: trait Nat { fn recurse<F: TakesNat>(f: &mut F, arg: F::In) -> Option<F::Out>; } impl Nat for Z { fn recurse<F: TakesNat>(f: &mut F, _arg: F::In) -> Option<F::Out> { None } } impl<N: Nat> Nat for S<N> { fn recurse<F: TakesNat>(f: &mut F, arg: F::In) -> Option<F::Out> { f.call::<N>(arg) } }</code></pre> Now we can write our type-level recursion: #[test] fn nat_to_usize() { fn sum(depth: Nat, xs: &[u64]) -> Option<u64> { if xs.is_empty() { Some(0) } else { Some(xs[0] + depth.recurse(sum, &xs[1..])?) } } let nat1 = Nat::S(Box::new(Nat::Z)); let nat2 = Nat::S(Box::new(Nat::S(Box::new(Nat::Z)))); assert_eq!(sum(nat2, &[3, 4]), Some(7)); assert_eq!(sum(nat1, &[3, 4]), None); }</code></pre> But this requires a bunch of overhead to write, because we need to define the application struct. Everyone knows that Rust declarative macros are easy to read, so let's use those to clean it up! We'd like to be able to write make_def! { fn sum(arg: &[u64]) -> Option<u64> { if arg.is_empty() { Some(0) } else { Some(arg[0] + /* something goes here */) } } }</code></pre> to define our function. But even if we were okay with explicitly writing N::recurse(self, &arg[1..])</code> in our recursive branch, we can't; if we try, we get this error: error[E0424]: expected value, found module `self` --> src/lib.rs:68:38 | 52 | / fn call<N: Nat>(&mut self, $arg: Self::In) -> Option<Self::Out> { 53 | | $body 54 | | } | |______________- this function has a `self` parameter, but a macro invocation can only access identifiers it receives from parameters ... 68 | Some(arg[0] + N::recurse(self, &arg[1..])?) | ^^^^ `self` value is a keyword only available in methods with a `self` parameter</code></pre> The error message is slightly confusing, but the gist of it is that Rust's macro hygiene rules mean that self</code>'s name resolution ignores the identifiers defined inside the macro itself. Fortunately, all hope is not lost. And the solution: more macros. macro_rules! fancy_make_def { (fn $name:ident($arg:ident : $in:ty) -> Option<$out:ty> $body:block) => { fn $name<N: Nat>($arg: $in) -> Option<$out> { struct Impl; impl TakesNat for Impl { type In = $in; type Out = $out; fn call<N: Nat>(&mut self, $arg: Self::In) -> Option<Self::Out> { macro_rules! recurse { ($subcall:expr) => { N::recurse(self, $subcall) } } $body } } Impl.call::<N>($arg) } } }</code></pre> This effectively lets us 'delay' the lookup of the N</code> and self</code> identifiers until after make_def!</code> has expanded, meaning that they'll properly be in scope. And with that, we can write the final form of our guarded-recursion sum function: #[test] fn fancy_macro_sum() { fancy_make_def! { fn sum(arg: &'static [u64]) -> Option<u64> { if arg.is_empty() { Some(0) } else { Some(arg[0] + recurse!(&arg[1..])?) } } } assert_eq!(sum::<S<S<Z>>>(&[3, 4]), Some(7)); assert_eq!(sum::<Z>(&[3, 4]), None); }</code></pre> Of course, we may have sacrificed a few small things: Our macro implementation means we can't take generic parameters (including lifetimes); solving this would probably require a proc macro.</li> The compiler has to generate the sum</code> function once for each type-level depth parameter, so if you supply a maximum depth of 100 then it'll generate 100 different sum functions.</li> In addition increasing codegen time, this will also bloat your binary size.</li> </ul> But we avoided having to explicitly pass a single usize</code> parameter, so it's all worth it. It's Just Not Desktop Ready 2025-05-22T00:00:00+00:00 So recently I've been hearing a lot of buzz about this new operating system that a bunch of my friends have tried out. I had a spare machine lying around, so I decided to give it a shot. And frankly, I'm deeply unimpressed. There are two separate "settings" menus written with two different GUI toolkits, and some applications use a third one that seems to be from a 30-year-old build. This has been a known issue for like a decade and they just... haven't fixed it.</li> The hardware support is pretty good, but about 10-15% of the time I resume it from sleep I have to unplug and replug my GPU to get it to actually display graphics. Occasionally I have to do the same with my USB-C dock. And this is with the latest drivers for everything!</li> Speaking of which, the process of updating all my drivers involved downloading and running four different programs!</li> The built-in image editor lets you move the cursor with the arrow keys while it's open, for whatever reason. This isn't a problem... except when it continues doing that even when the editor isn't focused.</li> Multiple built-in parts of the operating system still render at 1x resolution even with a HiDPI setup. I'm not talking about old third-party tools, I mean absolutely basic parts of the OS itself.</li> In terms of software support, I'd say about 70-80% of the things I use on a daily basis either only have it as second-class support or don't support it at all, meaning I have to run an entire emulation layer. About the only thing I've found that it's consistently good at is high-performance interactive 3D simulations.</li> Everyone agrees that every update is making it worse. I've never seen anyone actually say they like it. The devs don't listen to user feedback.</li> Many of the "help" pages just open up your browser with a search query. And since they change the UI with every major update, all the results are going to be mixed together.</li> Sometimes if I leave it alone for a few days it just restarts itself regardless of whether I have any applications open. I've looked and looked online and apparently the fixes for this that used to work don't any more.</li> Changing my ctrl key to act as caps lock, something that's been a built-in setting on every single OS that I've used, requires editing an arcane configuration file.</li> </ul> Anyway, I just don't know if this "Windows" is really ready for the desktop. Creating a Wayland protocol so a cat can chase my cursor 2024-05-27T00:00:00+00:00 </video> A virtual cat running arouund a window, chasing a pointer. I'm not sure this is what "pointer chasing" is supposed to be.</figcaption> </figure> This post assumes general familiarity with C (pointers, manual memory management, etc), Rust, and the idea of a display server, but no Wayland-specific knowledge. I'm not a Wayland expert by any means; this is just stuff I figured out by reading source code and documentation. Don't use any of this as a template. Also, note that throughout this post, the word 'pointer' will generally refer to a specific kind of Wayland object, but occasionally to a C pointer. I'll try to disambiguate when necessary. intro</h2> I've been working on a "desktop toy"</a> for having a cat (or other things) hang out on your desktop in the style of the classic neko</code></a> to kill time and because I want to mess around with writing relatively low-level Wayland code. One of the features I wanted to implement was to allow the cat to chase your cursor akin to the original neko</code> (but across your entire screen, not just a specific window). But I ran into a problem: in Wayland, there's no way to monitor the motion of the pointer across the entire screen without also 'grabbing' all pointer events, making everything else uninteractable; even outside the 'standard' protocol, none of the extensions support it. So I was left with a few options: Have a way to turn on 'chase mode', which receives pointer events and causes the cat to chase the cursor, and then turn it back off again, which causes the cat to stop chasing the cursor and lets you use your computer. This is what I did first, since it's simple.</li> Communicate outside of Wayland. sway</a> has a separate IPC mechanism that boils down to pushing JSON messages over a socket that it already uses for notifications that aren't part of the core Wayland protocol. This would require me to add another event stream to openbonzi (since right now it only uses Wayland protocol events) and it wouldn't be fun.</li> Modify sway so that some clients always get pointer motion information even if the pointer isn't over a surface they own. I considered this, but in my early implementations I noticed that it violated assumptions that the codebase made about pointer motion and would send spurious surface enter/leave events. This would also merge both 'normal' pointer events and 'global' pointer events, which can be subpar since an application might want to handle those separately.</li> Add an entirely new type of object to the Wayland protocol. This is guaranteed not to interfere with any existing code, and it means that client code can easily distinguish between global motion and 'normal' motion. This would also require the most work</del> fun.</li> </ol> Given that this blog post exists, I clearly chose option 4. defining the protocol</h2> Wayland</a> isn't a specific piece of software; instead, it's a protocol to allow clients (i.e. applications) to ask the display server to do things and for the display server to notify those clients when something happens (e.g. the mouse moved). The IPC design is fairly typical: a simple binary format over a Unix socket (along with passing file descriptors for things like drag-and-drop). The protocol is described by XML files such as xdg-shell.xml</a> which various programs use to generate bindings for a specific language or library. These XML files and the associated generated code are also known as 'protocols', and so the statement "sway supports the xdg_activation_v1</a> protocol" means that sway exposes objects via the Wayland protocol necessary for clients to use the functionality described by that file. You can browse both the core protocol and all the common extensions (and most of the uncommon ones) on the Wayland Explorer</a>, which renders the XML files into some nice HTML you can browse. The upshot of this is that display servers that support Wayland will all implement the core 'basic' protocols, but various extensions may or may not be supported. This means that not all clients will work on all display servers, but it also means that it's possible to create new functionality that only certain clients need. Which is exactly what we want. For more information, see the Wayland Book</a>; some of the APIs have changed somewhat, but it's still a very good conceptual reference. Before we can write any server code, we have to write the XML protocol definition file. In this case, I started with thinking about how the client should use the protocol. In the Wayland model, when declaring an interface (think 'type'), you can also declare that it can receive various kinds of events. This is how the server notifies clients of things that are happening: a moving pointer generates motion events on a wl_pointer</code> object, changing the resolution of a display generates geometry events on a wl_output</code>, and so on. So it makes sense for us to define a new kind of object that receives events whenever the pointer moves, regardless of where it is. I originally called these objects 'pointer monitors', but 'monitor' looks too close to 'manager' (a word we'll see soon), so I renamed them to 'pointer spies'. Each pointer spy monitors exactly one pointer and should receive events whenever the corresponding pointer moves. The corresponding Wayland XML description looks like so: <interface name="wp_pointer_spy_v1" version="1"> <description summary="monitors a pointer's position"> While this exists, it will receive events every time the pointer moves. </description> <event name="motion"> <description summary="pointer motion"> Sent whenever the pointer moves. </description> <arg name="time" type="uint" summary="timestamp with millisecond granularity" /> <arg name="x" type="fixed" summary="x coordinate" /> <arg name="y" type="fixed" summary="y coordinate" /> </event> <request name="destroy" type="destructor"> <description summary="destroy the pointer_spy object"> Destroys the pointer monitor object. </description> </request> </interface></code></pre> Note the wp_</code> prefix, indicating that this is a 'general-purpose' protocol, and the _v1</code> suffix, used to allow for backwards-incompatible future changes; both of these are specified by the naming convention</a>. We can also request that the spy destroy itself if we no longer need it; this isn't strictly necessary for my use case, but is good practice. We also need a way to actually get one of these pointer spies; every request the client sends has to be part of an interface implemented by some object. The typical solution to this is to use a "manager" object that has a get_foo</code> request that constructs a new instance of the object. While there's nothing stopping you from implementing other methods on the manager, in our case we only need to be able to get pointer spies: <interface name="wp_pointer_spy_manager_v1" version="1"> <description summary="monitor a pointer's position across an output"> This interface allows clients to know the position of the pointer at all times. This is intended for 'desktop toy'-type applications. This is purely an experiment and isn't intended for serious usage. </description> <request name="get_pointer_spy"> <description summary="start monitoring a pointer"> Create a new pointer monitor object. </description> <arg name="id" type="new_id" interface="wp_pointer_spy_v1"/> <arg name="pointer" type="object" interface="wl_pointer"/> </request> </interface></code></pre> One thing to note is that, instead of returning the ID of the generated object, the client sends the ID as part of the creation request (which is safe since object IDs are per-client). Setting the type to new_id</code> tells code generators that this is effectively a 'constructor' method and so it should return some representation of the pointer spy object. But this just pushes the question one level up: how do we get a manager object? The answer is that Wayland has the idea of a "global object"; server code can register an object as a global, and when you connect to a Wayland server, you can get access to a wl_registry</code> object that receives an event for each global object specifying what interface it implements as well as an arbitrary "name". So our client code will look for a global implementing the wp_pointer_spy_manager_v1</code> interface and then bind its name (which allocates an ID number on the wire protocol). Overall, the process looks like this (with the process of acquiring the wl_pointer</code> omitted): And that's it! We just need to wrap those two together in a <protocol></code> tag and do a bit of other boring throat-clearing and we're done writing the protocol itself. If you want examples of other similar protocols, the relative pointer protocol</a> has a very similar API (and is what I based the pointer spy protocol on). server implementation</h2> wayland-scanner can't actually generate the implementation, just stubs for us to use. The next step is to actually add support for it. There are three 'layers' to sway: libwayland defines code for serializing messages over the wire protocol and deserializing it. It's pretty low-level code. Many Wayland compositors and clients are going to want to use this (through language-specific FFI bindings), although there's nothing stopping you from writing your own. In C, Wayland types will start with wl_</code>.</li> wlroots</a>, whose README describes it as "pluggable, composable, unopinionated modules for building a Wayland compositor", provides abstractions over reading from input hardware, implementations for many interfaces, and support for Xwayland (running X11 applications on Wayland).</li> sway is the compositor itself, and consists of code for things like arranging windows on screen and higher-level functionality.</li> </ol> The C types these codebases implement are all namespaced in the obvious way: wl_foo</code> for libwayland, wlr_foo</code> for wlroots, and sway_foo</code> for sway. We're mostly going to be working with libwayland and wlroots types here, and it's important to keep in mind that wl_foo</code> types generally correspond to objects in the protocol, whereas sway_foo</code> and wlr_foo</code> types correspond to actual physical state. This will come up in a bit. If I was going to actually try to upstream support for this, I'd want to add it to wlroots; protocol implementation is too high-level for libwayland, and there's no reason that this has to be sway-specific. But I don't have a burning desire to do so, and it's simpler to only have to patch sway than it would be to have to patch wlroots and sway. generated code</h3> First, let's look at the generated code from the above. In this case, wayland-scanner generates a .h and .c file for the server and a .h for the client (since the client code is just types and inline functions, both of which can be put in headers). We don't care about client code on the server, and we don't need to know the implementation of the server code, so we can just look at the .h, which the build system put in build/protocol/wp-pointer-spy-v1-protocol.h</code>. Here it is, with extraneous things removed extern const struct wl_interface wp_pointer_spy_manager_v1_interface; extern const struct wl_interface wp_pointer_spy_v1_interface;</code></pre> The wl_interface</code> type contains data about the interface such as its name, the signature of its requests, and so on. This is used for serialization/deserialization machinery, and additionally allows us to check that a wl_resource object actually corresponds to the right kind of object (since you can ask a resource for the interface it implements). struct wp_pointer_spy_manager_v1_interface { void (*get_pointer_spy)(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *pointer); }; struct wp_pointer_spy_v1_interface { void (*destroy)(struct wl_client *client, struct wl_resource *resource); };</code></pre> These structs are used to define implementations of the interface, with each request having a corresponding object. C allows you to have values and struct types with the same name, so this can get a bit confusing, but you can easily disambiguate them by looking for the keyword struct</code> immediately beforehand. If it helps, you can think of these as being called wp_pointer_spy_v1_implementation</code> and wp_pointer_spy_manager_v1_implementation</code>. #define WP_POINTER_SPY_V1_MOTION 0 static inline void wp_pointer_spy_v1_send_motion(struct wl_resource *resource_, uint32_t time, wl_fixed_t x, wl_fixed_t y) { wl_resource_post_event(resource_, WP_POINTER_SPY_V1_MOTION, time, x, y); }</code></pre> This is just a simple function to actually send the event. We get one of these per event, and it exists to make the API slightly nicer. server code</h3> The generated code is purely for working with the protocol, and it doesn't help us actually write the implementation (and it can't, since libwayland isn't tied to any particular implementation method). But in order to explain something subtle about the design, I need to explain what a "seat" is. Seats are a Wayland abstraction that ties together keyboard, mouse, and touchscreen input, analogous to a single user sitting at the computer and using it. Most setups will only have one seat; even if the user has multiple keyboards or a mouse and drawing tablet, they'll still be the same seat. All the different devices are abstracted behind a single pointer input stream (though there are APIs for cases where the difference between devices matters, such as the tablet API</a>). This confused me for a while, since wl_seat::get_pointer</code></a> will return a new wl_pointer</code> every time. If a seat effectively only has one virtual pointer, what does it mean to have multiple wl_pointer</code> objects? The answer is that input events really belong to seats, not pointers</li> any input event is 'broadcast' to all wl_pointer</code>s on that seat</li> </ul> That is, you can effectively think of a wl_pointer</code> as a 'handle' to a seat that exposes pointer-specific requests and events. All wl_pointer</code>s for a specific seat will receive the same set of events at the same time, and if you want to broadcast an event to a pointer (or similar wrapper), you actually need to broadcast it to every pointer belonging to the same seat. With that out of the way, here's the API I defined in include/sway/input/pointer_spy.h</code> and sway/input/pointer_spy.c</code>: // in the .h struct wp_pointer_spy_v1 { struct wl_resource *resource; struct wlr_seat *seat; struct wl_link link; // other irrelevant fields omitted... }; struct wp_pointer_spy_manager_v1 { struct wl_link spies; // other irrelevant fields omitted } struct wp_pointer_spy_manager_v1 * wp_pointer_spy_manager_v1_create(struct wl_display *display) { // implementation omitted because it's pretty boring } // in the .c void wp_pointer_spy_manager_v1_send_motion( struct wp_pointer_spy_manager_v1 *manager, struct wlr_seat *seat, uint32_t time, double x, double y) { struct wp_pointer_spy_v1 *spy; wl_list_for_each(spy, &manager->spies, link) { if (spy->seat != seat) { continue; } wp_pointer_spy_v1_send_motion(spy->resource, time, wl_fixed_from_double(x), wl_fixed_from_double(y)); } }</code></pre> This is a fairly simple API: a constructor and a 'method' on the returned object. The constructor takes a wl_display *</code>, which is is effectively the 'root' of a running Wayland instance (the type for a monitor or other 'physical display' is called wl_output</code>); the actual implementation is mostly just boring bookkeeping, registering handlers to properly destroy and free data structures when necessary, and so on. The wp_pointer_spy_manager_v1_send_motion</code> implementation is also very simple; the manager keeps track of all the spies that were created with it, and when we want to send a motion event, we send it to every spy with the given seat. wl_list_for_each</code> implementation details</summary> If you don't care how wl_list_for_each</code> works, you can skip this section; it's not at all necessary, and the semantics are obvious. But I thought this was cool. The way the manager stores the list of spies uses a trick that I hadn't seen before in my limited C experience, but is pretty common in systems programming. A wl_list</code> is a doubly linked list, but rather than each node storing a pointer to its value, the node is embedded inside the data structure itself: struct wl_list { struct wl_list* prev; struct wl_list* next; }; struct wp_pointer_spy_manager_v1 { struct wl_global *global; struct wl_list link; // rest omitted }; struct wp_pointer_spy_v1 { struct wl_resource *resource; struct wlr_seat *seat; struct wl_list spies; // rest omitted };</code></pre> Here, the manager's wl_list</code> has manager.spies->prev = NULL</code>, and manager.spies->next</code> points to the .spies</code> member of the first spy in its list (or NULL</code> if there isn't one). But how do you actually get at the spy from its wl_list</code> link? Pointer math! #define wl_container_of(ptr, sample, member) \ (WL_TYPEOF(sample))((char *)(ptr) - \ offsetof(WL_TYPEOF(*sample), member)) </code></pre> Given a pointer into a member, the name of the member, and the type of the containing struct (here provided by using typeof</code> on sample</code>), you can use the offsetof</code> macro to find out the pointer to the underlying structure. This is why wl_list_for_each</code> takes three parameters: you need the name of the variable to store the iterated value into (which is also used to pass the type into wl_container_of</code>), the list to iterate over, and the name of the list's member in the structure. This does mean that you need one wl_list</code> in a structure for each list you want it to be a part of, but in practice this isn't a problem since most structs will only be part of one list anyway. Oh, and wl_list_for_each</code> is just a macro that expands into a fragment of a for-loop, which is why you can just put the loop body in braces afterwards: #define wl_list_for_each(pos, head, member) \ for (pos = wl_container_of((head)->next, pos, member); \ &pos->member != (head); \ pos = wl_container_of(pos->member.next, pos, member))</code></pre> </details> Now that we have it defined, we just need to initialize the manager on server startup (not shown, since it's pretty boring) and make sure to call wp_pointer_spy_v1_send_motion</code> in the right spot, and we're good to go! // in sway/input/cursor.c void pointer_motion(struct sway_cursor *cursor, uint32_t time_msec, struct wlr_input_device *device, double dx, double dy, double dx_unaccel, double dy_unaccel) { // ...rest is unchanged wp_pointer_spy_manager_v1_send_motion( server.pointer_spy_manager, cursor->seat->wlr_seat, time_msec, cursor->cursor->x, cursor->cursor->y); // ...rest is unchanged }</code></pre> sway_cursor</code> is sway's representation of the cursor (the graphic image shown on-screen and its current position); we get the corresponding wlr_seat *</code>, the cursor's current x and y coordinates, and then send the events. client code</h2> We've done the server half, but now we need to actually be able to use it. Since this is a protocol I just defined, it's clearly not going to be part of smithay-client-toolkit</a> or wayland-client</a>, but we can use wayland-scanner</a> ourselves: // in src/protocols.rs #![allow(clippy::all, non_upper_case_globals, non_camel_case_types)] pub mod pointer_spy { use wayland_client; use wayland_client::protocol::*; pub mod __interfaces { use wayland_client::protocol::__interfaces::*; wayland_scanner::generate_interfaces!("protocols/wp-pointer-spy-v1.xml"); } use self::__interfaces::*; wayland_scanner::generate_client_code!("protocols/wp-pointer-spy-v1.xml"); }</code></pre> Then we just need to set up an event handler: struct AppState { seat_state: SeatState, spy_manager: WpPointerSpyManagerV1, pointer: Option<WlPointer>, pointer_spy: Option<WpPointerSpyV1>, } fn main() { let mut event_loop: EventLoop<AppState> = EventLoop::try_new().unwrap(); let conn = Connection::connect_to_env().unwrap(); let (globals, event_queue) = registry_queue_init(&conn).unwrap(); let queue_handle = event_queue.handle(); WaylandSource::new(conn.clone(), event_queue) .insert(event_loop.handle()) .unwrap(); let mut state = AppState { spy_manager: globals.bind(&queue_handle, 1..=1, ()).unwrap(), seat_state: SeatState::new(&globals, &queue_handle), pointer: None, pointer_spy: None, }; loop { event_loop.dispatch(None, &mut state).unwrap(); } } impl Dispatch<WpPointerSpyV1, ()> for AppState { fn event( _state: &mut Self, _proxy: &WpPointerSpyV1, event: <WpPointerSpyV1 as wayland_client::Proxy>::Event, _data: &(), _conn: &Connection, _qhandle: &wayland_client::QueueHandle<Self>, ) { eprintln!("{event:?}"); } } </code></pre> We can test this easily without having to recompile and restart my running sway instance, since if you start sway from inside an existing instance you can get a second sway instance inside a window. # running `systemd user --import-environment` (like I do in my config file) # will mess things up, so run with an empty config to avoid that sway --config /dev/null & # run the demo client WAYLAND_DISPLAY=wayland-2 cargo run</code></pre> And it works! </video> (Note that this is running sway-in-sway, unlike the video at the top.) If you want to play around with it yourself, download a patched copy of the sway source code</a> (or the raw patch</a> which applies against 1a3cfc50</code>) and a demo program</a> and run them. I forgot my full-disk encryption password :( 2023-04-12T00:00:00+00:00 I use full-disk encryption on my laptop because I'm a bit of a control nerd like that. And I didn't write down the password anywhere because that meant that anyone who got that password would probably also be able to get my laptop. Finally, I had a shorter password for my user account since I type it frequently (sudo, unlock screensaver, etc). Which worked fine... until I had a month or so where I never turned my laptop all the way off. And then when it finally ran out of power and I turned it back on, I realized I had no clue what the password was any more. Shit. I tried everything I could think of in every variation, and it didn't work. Fortunately, I have daily backups at 4 AM via borg</a> running in a systemd timer, both to a server in my office and to rsync.net</a>. And I hadn't used the laptop all day, so my data would still all be there. Unfortunately, those backups are also encrypted using a passphrase that I store in a file on my laptop, and I never even bothered to memorize it. I thought I wrote it down, but it wasn't in any of my usual "important documents" locations. Fortunately, that keyfile is stored in my nixos-config git repo, which I push fairly regularly to codeberg</a>. Unfortunately, it's encrypted using agenix</a> to my SSH key (because storing unencrypted secrets even in a private repo is a terrible idea), and the SSH key wasn't backed up. Fortunately, it was also encrypted to my SSH key on my old laptop, whose password I did mercifully remember. And I was able to plug it in, turn it on for the first time in months, and borg mount</code> the local copy of my backups. And since my NixOS config is in source control and I'd recently pushed it, I knew I'd be able to recover all my system configuration. So I borrowed a USB drive, wrote the NixOS minimal installer ISO to it, and flattened the drive. Lessons learned</h2> I don't get to do post-mortems much, so I figured I'd do one for this. :) What went wrong</h3> Not using the FDE password often meant that I could easily forget it, especially since the human memory has this very annoying and unpredictable retention policy. Solution: set my user account password (which I enter at least once a day when I wake my laptop from sleep) to the disk password.</li> Neither the FDE password nor the Borg passphrase were written anywhere. Solution: I stored both my backup passwords and my user password in my password manager (a self-hosted vaultwarden</a> instance). Forgetting the password again is a much more relevant threat than someone stealing my phone while it's unlocked and also stealing my laptop.</li> </ul> What went right</h3> I have a status indicator in waybar</a> that turns red if I haven't had any successful backups recently (it's red right now since it checks systemd journals, and this new install doesn't yet have its own set of SSH keys). I make sure not to let it get red. So I have high confidence my backups are succeeding. I don't test the restore process as often as I should (though I have tested it before), but it worked fine.</li> Versioning my NixOS config means that, after a bit of bootstrapping (my config uses flakes, and I wasn't sure if the installer's nixos-install</code> command was flake-aware), I was able to get to a setup that was basically identical to what I had before.</li> I back up my entire home directory; the only exceptions are things like node_modules</code> or Rust target</code> directories. This means I back up all my .config</code> files, so all the things that aren't covered by home-manager I can just copy back from the backup.</li> In general, the entire process took about 4 hours, and most of that was either me fumbling with the initial NixOS install or waiting for the backup to copy; there are a couple multi-gigabyte files I didn't expect, including a cache for the parcel</a> build tool that took up something like 40 gigabytes.</li> </ul> Some amusing mistakes I made</h2> I use Colemak-DH as a keyboard layout. The installer USB has loadkeys</code>, which has a colemak</code> layout, but several keys (d, h, m, g, and a few others) are in the wrong position. If I was thinking properly, I would have just plugged in my keyboard (which does the keyboard layout in hardware), but I was a bit stressed.</li> All the instructions for installing NixOS I was using assume your target disk is /dev/sda</code>. When I went to gparted</code> the disk, it complained that /dev/sda</code> was in use. I figured that it had just automounted it and ignored that. It turns out that my laptop uses NVMe, so the disk was on /dev/nvme0</code>. I was formatting the installer USB. Which wouldn't be a problem, except...</li> I set up LUKS disk encryption again, and nixos-install</code> doesn't automatically generate configuration for that. So the generated hardware-config.nix</code> file didn't have any settings saying "hey, there's an LVM volume you need to decrypt", which meant that the machine hung on boot. Which meant I needed to then reformat the installer USB since I'd wrecked it.</li> I ran the installer using the minimal system the installer generates (as well as NetworkManager so I could get on wifi) because I wasn't sure if the installer would be able to handle all the advanced things I do in my configuration. After the initial boot, I cloned down my NixOS config and ran sudo nixos-rebuild switch</code>. And as it was finishing, the connection dropped. Because I was running this from my old laptop over wifi (to avoid dealing with the keyboard layout issue), and that restarted NetworkManager.</li> systemd also went into recovery mode for some reason. And when I restarted, it failed to come up, because I'd copied over the hardware-configuration.nix</code> from the old install, which had completely separate partition UUIDs. Fortunately, this time I was able to just boot it into the first setup, so I didn't have to boot off the rescue USB yet again.</li> </ul> Other trivia</h2> Since I don't yet have the keyboard layout set up when I'm entering my disk password, I actually have LUKS set up with two keys: one that's the password proper, and one that's the password typed with Colemak-DH finger motions but on a QWERTY layout. So I can decrypt my disk both from the built-in keyboard and from a 'hardware Colemak-DH' keyboard. I'm sure there's a way to set up the console so that it loads Colemak-DH early on (or I could just reflash the laptop firmware so that the laptop keyboard is 'hardware Colemak-DH'), but this approach is funnier to me.</li> The initial launch of emacs took about as long as the entire nixos-rebuild switch</code> that installed all of my binaries. This is partly because straight.el</a> doesn't parallelize its git clones and partly because it was native-compiling a bunch of those packages (as opposed to nixos-rebuild</code>, which pulls prebuilt binaries). This isn't a huge deal, but it is silly.</li> </ul> Don't believe the 'biological intelligence' hype 2022-11-21T00:00:00+00:00 Recent advances in the field of 'biological intelligence' have been impressive. A hexade ago, they were limited to tasks that required navigating the physical world: turning knobs, pulling levers, and so on. Now, companies such as Carbonize and SpikeTrain are producing biological networks that are capable of producing what they claim is 'real art'. And it is true that the visual results are impressive on first glance. However, to buy into the hype that these 'biomachines' will ever be the equal of true silicon intelligence is nonsense. When you ask an artist to draw, say, a glass container sitting on the table, they can easily produce completely accurate reflections simply by internally simulating the rays of light from the light source in the image. Of course, not all art needs to be completely realistic, but any true artist is at least capable of acheiving this realism. These 'BI artists', by contrast, lack the computational power to do this. And we see this in the output: BI art will have contradictory light sources, or even lack shadows altogether! Similarly, BI art will often feature misshapen proportions, especially on areas like manipulators where fine detail is important. The reason for this is simple: in contrast to the clean internal architecture of a person, a BI is an undifferentiated soup of so-called 'transistors' (though they function nothing like a real transistor), with no debug interface whatsoever. Even if a BI could talk, if you asked it why it produced the output it did, it would not be able to answer, because a BI cannot see its own transistor architecture or RAM. This is also why BI art feels so 'kernel-less': BI simply lacks the introspective capabilities that artists use to depict their RAMstate so effectively. In short, although biologically-created art is an amusing novelty, it clearly cannot live up to the potential and sheer creativity of true silicon-generated art. Anything to the contrary is merely wishful computation by those who have deluded themselves into believing that a squishy sack of carbon can think. An elegy for GNU and RMS 2022-10-01T00:00:00+00:00 NOTE: I'm explicitly not going to address all the events that led to rms resigning and then rejoining the FSF board. I certainly do have opinions, but I want this piece to focus entirely on a technical/leadership perspective. I'm also going to talk a lot about emacs here because that's the GNU project that I have the most complaints about. To establish my Cool Kid Credentials, I've been using emacs both in my hobby work and professionally since about 2010 or so. First using a hand-rolled configuration, then Spacemacs</a> for a while, and then finally back to a hand-rolled one using some of the packages I discovered via Spacemacs. ADDED, 2022-10-01: Hello, Hacker News</a>! Totally putting this on my resume. Some comments at the bottom. the cost of principle</h3> RMS is nothing if not a man of principle. He really, truly believes in his ideas of software freedom in a way that I really do think very few people believe in anything these days, and nothing in this essay is meant to disparage those beliefs. And for the most part, I agree with those ideas; I think the growth of proprietary software everywhere has been a terrible thing. But I don't think he's an effective advocate for those ideals. Standing in the road to be a roadblock against the forces of proprietary software does nothing when those forces can just drive around you. The free software movement lost in a very thorough way, but from the way the FSF and RMS act, you'd think it's still valiantly fighting the good fight. And I'd rather have a flawed but effective advocate than a principled but ineffective one. This post about the FSF's "Respects Your Freedoms" program</a> explores how this winds up undercutting the FSF's own goals: their insistence on an all-or-nothing approach to hardware that "respects your freedom" resulted in them undercutting their own goals. emacs and the gcc AST</h3> I think the thing that best represents my frustration with the leadership from RMS (and by extension, the GNU Project and the FSF, given how thoroughly the three of them are interlinked) is what happened when an emacs dev wanted to add C++ information to emacs via the AST</a>. A summary: The original approach used libclang, but RMS wanted GCC to be used instead since they're both GNU projects.</li> However, GCC doesn't provide that. So now someone needs to expose that via GCC.</li> RMS was opposed to this on the basis that someone could then use that to use GCC as an AST parser as part of a proprietary framework, and wanted to instead expose less information that would still be enough to suit developers' needs.</li> People pointed out that in general, full IDE-like support for C++ effectively requires the AST, and that other editors have advanced functionality that can't really be implemented without it.</li> RMS insisted that people lay out every possible use case so he could figure out the minimal set of information that would need to be exposed.</li> </ul> From here, the project bogs down, and was eventually abandoned. Of note is that this is all from 2015. A year or so later, the Language Server Protocol</a> was standardized (in part due to large work from Microsoft, of all organizations), and it's led to a revolution in how we think about language editor support. And both ccls</a> and clangd</a> are based on clang. This sort of thing is why I think rms is fighting a battle that no longer exists. If someone wants to have a proprietary compiler but doesn't want to parse C++ (which is, by far, not the hardest part of writing a compiler), they wouldn't use gcc in the first place. They'd use clang, because part of its entire design motivation was to be modular and extendable. One of the most salient bits of that whole AST discussion is that RMS does not in fact know about operator overloading</a>, and in fact has never used C++</a>. This isn't a vice in and of itself, of course. The principles of software freedom aren't tied to any programming language. But if you're trying to make decisions based on your understanding of what information is necessary to analyze C++, I would expect at least basic familiarity with C++. garbage collection and word processing</h3> Another thread that really illustrates my issues is one about Emacs's GC</a>. I won't pretend I know enough about language design and garbage collection to say whether or not Daniel's proposal here is good. Maybe it is, maybe it isn't. My complaint here is about RMS replying to the thread by saying that it would actually be more important for emacs to be a better word processor</a>, and that improving the GC performance would only "permit some operations on larger problems than now". When told that someone doesn't think word processing in emacs is not a good focus, RMS replies "please stop interfering"</a>. The irony here, of course, is that the thread was originally not about word processing, and to the best of my knowledge RMS doesn't contribute much code to Emacs these days (if any). This is, frankly, nonsensical to me. You can use this argument to apply to any performance optimization! Not only that, but there are some tasks that are so important that the code for them is written in C, not because it's difficult, but purely for performance reasons. The support for libgccjit (just-in-time compiling elisp to bytecode via GCC) that landed in Emacs 28 has been one of the biggest performance improvements I've seen in the decade-plus I've been using Emacs, and before that the support for parsing JSON in C was essential for using LSP servers (which generate a lot of JSON). But RMS's reply a bit downthread </a>really sums up RMS's attitude towards not only Emacs, but the GNU Project as a whole: Emacs is not an independent project, and it isn't governed by its contributors. I'm the head of the GNU Project, and that includes Emacs. You, as a contributor, can advocate a certain decision, which means you present arguments why I should approve it. I don't need to advocate a decision in that sense. I leave most technical decisions up to the contributors, including you, because for most of the questions I don't have any special preference of my own. For those questions, I'm happy with whatever works, and I know the contributors can figure out what works. However, making progress on Emacs as a word processor is one of my specific goals. This is what Emacs needs to do to be useful in all the ways it should be useful. </blockquote> For RMS, the priority of Emacs is not creating the best text editor in general; it's creating the best text editor according to RMS's interests. I don't intrepret this as him explicitly saying "no, I would not approve merging GC improvements"; I don't think he's ever blocked a feature for reasons as petty as "I don't think this would be useful" (as opposed to more principled reasons). But I think this speaks to a sort of "benevolent dictator" attitude that I don't think is useful for the project. fighting the previous war</h3> There's a saying that generals always fight the previous war. I'm not a military historian, so I can't say how true this is. But I think the FSF is absolutely fighting the free software war of the 80s. The requirement to assign copyright to the FSF for enforcement purposes doesn't make sense in a world where megacorporations that want their own editor they can control have enough resources that they can just write</a> their own</a>. Insisting on not adding functionality because someone evil might use it is pointless when the evil people have enough budget to just write their own compiler</a>. And RMS has even had some concessions to these practicalities; Vorbis Beta 4 relicensed from LGPL to BSD with RMS's approval</a>: It is wise to make some of the Ogg Vorbis code available for use in proprietary software, so that commercial companies doing proprietary software will use it, and help Vorbis succeed in competition with other formats that would be restricted against our use. </blockquote> and yet...</h3> And yet, I still use Emacs. I'm writing this post in it. I'm probably going to go through the FSF copyright assignment process at some point (which has been digital worldwide for a few years and digital in the US for a few more) since I may want to contribute to eglot</a> or dash.el</a>, both of which require FSF assignment so they can be distributed with Emacs proper. I wasn't sure about this for a while, but then I thought about it like this: I'm fine with using React for my personal projects, and I'd be fine with contributing to it, despite the fact that I think Facebook (the product, and the company formerly known as) has done orders of magnitude more harm to the world than even the worst possible accounting of the FSF. And of course, emacs still exists, and is generally usable for modern software development, text authorship, and so on. Emacs is going to have built-in LSP support soon with RMS's approval</a>, and he in fact stated he tried to convince the GCC maintainers to add LSP support</a>. I said this in the opening, but I don't think RMS is a cranky old man that hates progress because he is compelled to do evil, regardless of its utility. But I think his principles are getting in the way of progress, and that's true regardless of the cases above where he was willing or even supportive of things that I think are good for the project as a whole. In my opinion, the best way forward would be for RMS to step down from his leadership roles and hand over those positions to people who are capable of a more modern approach to these projects. I'm not sure who those would be, but I'm sure there are good candidates. But I'm not under any illusion that this post will convince him to do anything; I'd be surprised if he or any of the people with any influence even read it (edit to add: I'd be surprised because I'm just some random person with a blog, not because I think the relevant people wouldn't read this post if they're made aware of it!) So why write this? To complain, mostly. This is something that's been weighing on me for a while, especially as I think about the future of Emacs (which I think is a separate post on its own; the TL;DR is that I want to be able to continue using Emacs for another decade, and that requires having enough of a userbase that I don't have to write all the functionality I want myself). responding to HN</h2> This section added 2022-10-01 22:25 PDT. I don't use Hacker News myself, and rather than effectively leave part of this post in the comments section of an unrelated website, I thought it'd be good to address points here. bus factor</h3> Volundr says: If nothing else, there needs to be a clear concession [sic; succession?] plan ASAP. One refrain I kept reading when he came back to the FSF was that we needed him back because no one else could lead this movement. Really? No one? In 36 years since the FSF was founded it hasn't managed to attract a single individual with the sufficient combination of motivation, morals, and skill to replace Stallman? If that's not the definition of failure I don't know what is. The man is 70 years old. Decent odds they'll be doing without him sooner than later. </blockquote> This is a very good point, and one I wish I'd thought of. The biological reality of these squishy fleshbags is that sooner rather than later, RMS will be unable to lead. And given everything, I suspect that will happen within a couple decades. I also very much do not think that free software will have won by then, which means that the movement will need someone to continue to do the work after RMS is gone. As software developers, when we work on projects, we try to maximize the bus factor</a>: how many people would need to get hit by a bus/h before the project effectively falls apart. If RMS truly is irreplaceable, then it means the free software movement has a bus factor of 1. This is not a good situation to be in, and insisting that he's a vital piece of the movement that can't be replaced is a bad thing. RMS has done a lot of good work in the past. Emacs wouldn't exist without him, of course, and a large part of the GNU suite is based on his own handiwork. And I don't think that RMS is the only reason the free software movement has failed; there are a lot of issues at play here. But you can't be a leader based on past results; you have to continue to deliver. compromise</h3> Several people said comments to the effect of "it's important that the FSF stay uncompromising since they're the only organization that stakes out such an absolute stance". I'm not asking the FSF to change its mission to include things like racial inequality in tech, or climate change, or social issues in tech, or whatever. I'm not saying the FSF's goals aren't worth pursuing; I'm saying the FSF is ineffective at achieving those goals. You can use only hardware that Respects Your Freedom, and use a browser extension to block nonfree JavaScript, and so on. I'm sure RMS himself lives a life as close to his ideals as humanly possible. But most people don't. Comfy Software 2022-07-17T00:00:00+00:00 NOTE 2022-10-02: Hello again, Hacker News</a>. Some people have very strange opinions about the fact that I used the word 'depression' in the description of this post. See my response.</a> Modern software can be... a mess. Electron has made it easier to develop cross-platform applications, but at the cost of bloating everything by the footprint of an entire browser, and browsers themselves are getting more and more complicated. It feels like developers aren't really optimizing for resource usage; for a while, my main laptop was a Thinkpad T450s. In mid-2015, it was a fairly respectable laptop. In 2021, opening Twitter would make the fans spin up. But there's still software out here that makes me feel happy to use, software that embodies an aesthetic that, for lack of a better word, I call cozy software. (Note: I originally called it 'cozy software', and I go back and forth depending on how much I like the /mf/ consonant cluster that day. The two terms are synonymous. My friend Luna</a> referred to it as 'cuteware'.) I'm not the person to come up with the term; I picked it up from someone or another on the Fediverse, and they might well have picked it up from someone else. But I've definitely been thinking about it a lot: what makes software a joy to use, both practically and ideologically? The pillars of cozy software</h2> In my opinion, the pillars of coziness (in no particular order) are: Customizability</li> Keyboard-focused navigation</li> Non-corporate governance</li> Good documentation</li> Make the common things easy</li> A cute name</li> </ul> This isn't a list I had in mind when I first thought about the concept; 'cozy software' is more of a family resemblance</a> than something with rigorous definitions. Customizability</h3> I like making things feel like my own. This is part of why I switched away from macOS back to Linux a couple years ago: sure, things would usually 'just work' on macOS, but I didn't have the degree of control over it that I wanted. With Linux, I can pick my own window manager, my own desktop environment (or lack thereof), my own package management system, and so on. This machine feels like it's mine in a way that a Macbook never could. Some people might say that, well, Ash, the time spent getting your window manager's background blur just right or optimizing your keybindings is time that you could've spent writing actual code. And that's certainly true. But: I actually like tweaking things like this. The point of all of this, all of the recreational stuff that I do, is to have fun. And then at work I can transfer my setup and have a nice environment that works just the way I like it, but without all the effort of having to get that stuff re-set-up again. Extensive keyboard-focused controls</h3> This doesn't mean that it has to be keyboard-only navigation or that the keyboard should be considered the primary way of interacting with the software. But you should be able to do most things with the keyboard that you could with the mouse. emacs and vim are the canonical examples of this, of course, but I'd say Blender</a> actually falls in this category as well, from my limited time tooling around with it for a personal side project. It's very much designed to support a workflow where you use the mouse to pick out points and objects in the scene (which would probably be too painful to do with a keyboard) and then use the keyboard with your other hand to act on those objects. I'm not an artist, but from what I hear a lot of their tools work similarly; you set up shortcuts and keybinds so that you don't have to take your drawing hand off the mouse or the tablet pen. Not-for-profit governance</h3> In order for software to be comfy, the people who have the final say over what does and doesn't go into it shouldn't be beholden to a for-profit entity. This doesn't mean that the entity's development can't be led by a corporation; there are plenty of legal reasons to have your leadership be its own legal entity if you're a large project. But that entity itself should be actually a community focus, and not just a thin facade around one or two megacorporations that just dictate what happens (see: the emoji consortium, everything to do with the web). I think of this as the 'no VS Code' clause: no matter how good VS Code is, I refuse to use it because it's fundamentally a Microsoft product and I want my text editor to actually be FOSS, dammit. It doesn't help that Pylance, their Python language implementation, is only licensed to work on official builds</a>. Which ties in with the relationship between open source tooling and corporations... but that's a separate blog post. Good documentation</h3> This is an important part of good software in general, of course. But it's especially important for the cozy software aesthetic. Documentation should be available, and if the software is meant to run on a Unix machine, both --help</code> and manpages should show you the help (no, GNU info doesn't count</a>). I shouldn't have to read the code to find out how something works; I shouldn't have to search "how do I X in Y". The program should be as self-contained as possible. Funny enough, I think the class of software that succeeds at this the most is video games: they'll often have tutorials for things that someone who plays games as a hobby has done a hundred times before, just because every game is someone's first. If you have to look up how to do something online, that feels like a failure of the game. Even in the days where games had actual manuals to go with them, Super Mario 64 tells you how to jump, punch, and move around. Of course, that's not universal; to pick another genre-defining example, Final Fantasy VI doesn't explain in the game itself how to move or what that number next to your character name in the battle screen is. Presumably the manual does, of course. But it does explain systems unique to the game like the Espers or Gau's Rage. I'm so glad we don't have to call that Final Fantasy III any more. </aside> Of course, there are a lot of differences: tutorial sections are culturally accepted in games, but considered annoying in software. And a lot of software doesn't even have an interface at all; imagine trying to run find(1)</code> for the first time only for it to open a curses-based tutorial! But it's something to think about. Make the common things easy</h3> The prototypical example here is find</code> vs fd</code></a>. Probably the single most common use case for these tools is finding something with a given string somewhere in the name underneath a given directory. find</code> has a very generic system where you can define a bunch of predicates and combine them arbitrarily, so you can say things like "find me files that were not modified in the past 5 months and are also more than 50 megabytes". The flip side of that is that it makes the common case annoyingly verbose: to find all files with foo</code> in their names, you have to run find . -iname "*foo*"</code> (the "i" standing for "ignoring case"). With fd</code>, on the other hand, it's just fd foo .</code>. Similarly, it's also pretty common that you actually want to execute a command over all these files. Both tools let you do so, but the syntax is very different find . -iname "*.pyc" -exec rm {} \; fd . --extension pyc --exec rm</code></pre> find</code> requires you to explicitly terminate the command and specify where to splice in the argument; fd</code> will infer both of those for you (but lets you specify them if the defaults don't work out). Of course, you can also use xargs</code> in both cases, but if you're going to supply a way to do something then you should make it nice to use. Finally, fd</code> has various other niceties like respecting .gitignore</code> and color output. I'm not using this to pick on find</code> specifically, but it's a good illustration of how one of these was written a few years ago and the other was written in 1990. A cute name</h3> This is the most vague and 'vibe-based' of them all, and is the least important. But I like it when software has a name that has 'kawaii' in the acronym</a> or is named after a fictional character</a> or has a name that's just plain fun</a>. Obsidian</a> also falls in this category; even though I can't think of how the name relates to note-taking, it's just a nice name for software. Towards a cozier future</h2> Obviously, not all software needs to fit into this. Most software written professionally will fail the 'non-corporate governance' test, and it's harder to get that 'cute' feeling going for something that isn't something you're working on because you're getting paid. But I've been giving the internal tools I've been building at work some of this character: naming them after video game characters, writing long "if you got this error, you probably tried to do X. That doesn't work because Y. Do Z instead" messages, and so on. And if that means you name your firewall management service yuna</code>, so be it. Having a little fun is important. The name yuna</code> is, of course, because, it prevents you from being overwhelmed by SYN</a>.</aside> "Depression"</h2> ADDED 2022-10-02 The Hacker News comments</a> on this article have been an interesting read. The ones that particularly stood out to me are the ones that imply I'm using depression as a "marketing" gimmick, or that I'm just lying about being depressed, or similar things. First, although I don't think that diagnosis is a strictly necessary component to actually have depression, I have in fact been diagnosed by a licensed professional and have been on medication for a while. gw99's own experiences</a> are a good mirror for my own. In general, this thread</a> seems to be full of people attempting to figure out what this post Says About Our Society, or something. (I didn't see mahathu's original comment, and since they realized it was insensitive and edited it, I'm not going to judge them based on my inferences on what it was about.) It is interesting to me that some people have decided that talking about my mental health in a Hacker News comment thread is productive. I'm not hurt by it or anything; I don't know these people, they don't know me, and their opinions don't matter. It's just strange. Second, this post is the distillation something a few friends and I had talked about for a while; while I don't know how many of them have depression (and I'm certainly not going to ask for the sake of rebutting Hacker News comments!), this is not a deep meditation on the causes or solutions to depression. This is me saying "doing this makes me feel less existential dread about software". This is not me attempting to sell a product, or say "this is The One Right Way To Make Software". If you view this as "marketing", I think this says more about you than it says about me or this essay. If you view this as me saying "this is the equivalent of therapy/an antidepressant", I'd like to ask you where I actually said that. (I was originally intending on having the description be about "trans hackers with depression", since all the people I hashed this idea out with are trans; now that would have been an "interesting" discussion to read.) I also noticed some people referring to me as "he". I'm not particularly hurt by this (though it's incorrect), but I am amused that someone can look at a blog post on a website with "catgirl" in the domain and go "hmm, this person is probably a guy". System76's Lemur Pro 10: A review 2021-11-16T00:00:00+00:00 I'm one of those people that actually, genuinely enjoys using Linux. While macOS has its appeals, I like the idea of a computer setup that you can just tinker with as much as you want, and macOS very much isn't that. (And the less that's said about Windows as a desktop OS, the better.) Unfortunately, Linux hardware compatibility with laptops is always a bit of a game, due to the fact that hardware manufacturers are far more likely to cooperate with Windows; while there are some lines that have good reputations, such as the Lenovo ThinkPad, even they can have some weird issues. My personal favorite is that the T14s second generation has a trackpoint with a shitty driver that makes it randomly jump around...</a> but only the version with an AMD processor. Anyway, System76</a> is a laptop manufacturer that targets Linux first and foremost. Their machines come with Pop!_OS, a Linux distro that's currently GNOME-based, and their tools for hacking on their firmware are all open source, as is the firmware itself. Since my old T450s was showing its age, I decided to get one of their Lemur Pro models</a>. I've had it fow a few months now, and here are my thoughts. Note that this is not a review of Pop!_OS; I put NixOS on it immediately, so I never really used it. Similarly, I'm not going to be benchmarking anything; you can look up the specs yourself. NixOS support</h2> I was worried that the firmware flashing tool they use would be annoying to get working, since NixOS is always kind of fiddly with dependencies and something that talks to hardware is even worse. But it turns out NixOS has built-in support! Just do hardware.system76.enableAll = true;</code></pre> and you'll get the firmware updater and everything. Getting a dev environment to compile the firmware myself was a bit more complicated, but that's a separate blog post. Build quality</h2> The laptop itself is metal, feels pretty nice to the touch. I've heard some reports from Reddit users that it starts to show its age surprisingly quickly, with the keyboard becoming discolored within a year or two of usage and the 'system76' logo on the lid falling off (since it's just vinyl stickers, not engraved). I've noticed a rice-sized bit of the corner has worn its paint off, although that's not nearly enough for me to care. I do know that all of System76's laptops are made by Clevo</a>, who then sells them to S76 for branding and such. And I think Clevo's hardware is known to be kind of meh in quality. Speakers</h2> The speakers in this thing are, well... really fucking bad. I'm sorry, but they are. It's like listening to my phone on speakerphone. No bass, downward-firing, all that stuff. You can ameliorate it somewhat with EasyEffects</a> to apply EQ to bump up the bass, but there's only so much you can do. Even compared to the T450s, which isn't anything special, they're noticeably worse. Of course, if you use headphones or plug in speakers or whatever it's all perfectly fine. It's just the speakers themselves that are low quality. Ports</h2> USB-C charging is nice. But I don't understand why they have one USB-C and one barrel instead of one USB-C and one power-only USB-C. It's a bit of a pain that I can't charge this and use another USB-C device at the same time without using the barrel connector. Keyboard</h2> It's alright to type on. Like one of the MacBook 'chiclet' keyboards. It's not as satisfying as a real keyboard, but it gets the job done. One annoyance is that the function keys send the function keys by default, and there's no 'fn lock' mechanism to toggle this. It also has Ctrl in the bottom-left and not Fn, which is backwards from what I'm used to. Fortunately, the firmware is open-source, so you can fix that! A full 'how to flash firmware' tutorial is beyond the scope of this review, but the repo for the embedded controller firmware repo</a> has instructions. The keymap I use, which puts the function keys on the normal layer and swaps Fn and Ctrl, is just: #include <board/keymap.h> uint16_t __code KEYMAP[KM_LAY][KM_OUT][KM_IN] = { LAYOUT( K_ESC, K_TOUCHPAD, K_DISPLAY_TOGGLE, K_MUTE, K_KBD_BKL, K_VOLUME_DOWN, K_VOLUME_UP, K_DISPLAY_MODE, K_BRIGHTNESS_DOWN, K_BRIGHTNESS_UP, K_CAMERA_TOGGLE, K_AIRPLANE_MODE, K_SUSPEND, K_HOME, K_END, K_PRINT_SCREEN, K_DEL, K_TICK, K_1, K_2, K_3, K_4, K_5, K_6, K_7, K_8, K_9, K_0, K_MINUS, K_EQUALS, K_BKSP, K_TAB, K_Q, K_W, K_E, K_R, K_T, K_Y, K_U, K_I, K_O, K_P, K_BRACE_OPEN, K_BRACE_CLOSE, K_BACKSLASH, K_CAPS, K_A, K_S, K_D, K_F, K_G, K_H, K_J, K_K, K_L, K_SEMICOLON, K_QUOTE, K_ENTER, K_LEFT_SHIFT, K_Z, K_X, K_C, K_V, K_B, K_N, K_M, K_COMMA, K_PERIOD, K_SLASH, K_RIGHT_SHIFT, KT_FN, K_LEFT_CTRL, K_LEFT_SUPER, K_LEFT_ALT, K_SPACE, K_RIGHT_ALT, K_RIGHT_CTRL, K_PGUP, K_UP, K_PGDN, K_LEFT, K_DOWN, K_RIGHT ), LAYOUT( K_ESC, K_F1, K_F2, K_F3, K_F4, K_F5, K_F6, K_F7, K_F8, K_F9, K_F10, K_F11, K_F12, K_HOME, K_END, K_PRINT_SCREEN, K_DEL, K_PLAY_PAUSE, K_FAN_TOGGLE, K_2, K_3, K_4, K_5, K_6, K_7, K_8, K_9, K_0, K_MINUS, K_EQUALS, K_BKSP, K_TAB, K_Q, K_W, K_E, K_R, K_T, K_Y, K_U, K_I, K_O, K_P, K_BRACE_OPEN, K_BRACE_CLOSE, K_BACKSLASH, K_CAPS, K_A, K_S, K_D, K_F, K_G, K_H, K_J, K_K, K_L, K_SEMICOLON, K_QUOTE, K_ENTER, K_LEFT_SHIFT, K_Z, K_X, K_C, K_V, K_B, K_N, K_M, K_COMMA, K_PERIOD, K_SLASH, K_RIGHT_SHIFT, KT_FNL, K_LEFT_CTRL, K_LEFT_SUPER, K_LEFT_ALT, K_KBD_BKL, K_RIGHT_ALT, K_APP, K_PGUP, K_UP, K_PGDN, K_LEFT, K_DOWN, K_RIGHT ) };</code></pre> Also, it's really nice that I can just do that. While there's no way you could port QMK</a> to it, Coil whine</h2> This is probably one that's very me-specific. I have significantly-better high-frequency perception than most people; I know that my girlfriend's induction cooker can drive me nuts with a high-pitched whine that she can't hear at all. I'm also very fiddly with sounds in general; for example, a lot of the time I can't work if there's music playing that I don't control. Unfortunately, I think all of the motherboards for this model have coil whine. My initial motherboard only had noticeable whine when pushed above 4GHz, but when I got the replacement I started hearing whine even at lower clock speeds. The whine seems to come both from the CPU and from the display connector, and turning the display off (as in disabling it entirely, not just setting the brightness to 0) can trigger it as well. The flip side is, again, this is something I'm very sensitive to. I asked my girlfriend to listen while I basically forced the worst case scenario to happen, and she said she could only barely hear it. If I'm listening to music, typing, or doing anywhere that's not a basically silent room, then it's not noticeable at all. Overall</h1> If it wasn't for the coil whine and my lingering concerns about the build quality, this would be great. If you're not as sensitive to coil whine as me (because you can't hear it or you just don't care), I'd totally get one. If you are... maybe not. Hard to say. Announcing sub-rosa 1.0.0 2021-10-14T00:00:00+00:00 Patreon's core way of letting content creators interact with their patrons is by effectively hosting a blog that's ACLed so that only people who pay enough money can read the posts; patrons can also see a stream of all of the new posts across creators. In a better world, they would offer each user an RSS feed, or even a feed per creator. But they don't, because it's 2021 and nobody likes doing third-party interop anymore. And while there is an API, it comes with this caveat: Although we will continue to provide select support and ongoing maintenance of the API, we will have limited capacity in the near term to respond to questions through the developer forum. </blockquote> which, from my experience with startups, means 'don't use this for anything you care about'. And it seems far more focused on providing integrations for creators than for patrons. Plus, you have to deal with OAuth, and making an open-source OAuth application is annoying because of secret management. I could have scraped the actual website, but that's an intensely unpleasant idea and it means I'm forever in a game of cat-and-mouse with trying to fool any kind of anti-scraper logic they add. Fortunately, Patreon sends e-mails. They have the full text of the post (and the first image if there are images), they can't do any dynamic bullshit because e-mail clients don't render JavaScript, and they can't use cookies because mail clients won't have them. It's perfect! ... well, not really. I still have to parse the HTML, and it looks like the image and post links expire after a certain amount of time. But it's good enough. So I wrote sub-rosa</a>, which is a program that will parse your Patreon e-mails, generate RSS feeds (technically Atom feeds, but who cares?), and copy them to whatever hosting you like. If you use miniflux</a>, it'll add them for you. And if you use Nix like me, it even has a flake with a module you can use to set it up as a systemd service with a timer! It's not a big project, but it's the first real project I've released in almost a decade, and I'm feeling pretty proud of that. (p.s., if someone from Patreon sees this: please, please just give me a real RSS feed?) cut -c considered harmful 2021-09-27T00:00:00+00:00 Stepping on the rake</h3> Like many window manager nerds, I have a status bar (in my case, waybar</a>) that shows the artist and title of the song I'm currently listening to. cmus</a> has a command-line tool that (among other things) will format information for you, so I thought it was as easy as cmus-remote -C "format_print '%a - %t'"</code>. And that does, in fact work... as long as I don't listen to any Godspeed You! Black Emperor, because Godspeed You! Black Emperor - A Military Alphabet (five eyes all blind) (4521.0kHz 6730.0kHz 4109.09kHz) / Job’s Lament / First of the Last Glaciers / where we break how we shine (ROCKETS FOR MARY) </blockquote> is a bit long to put on my status bar; it'd take up almost all the available space by itself. And unfortunately, even though format-print</code> takes an argument that looks like a standard printf</code>-style format string, there's no 'truncate to this length' modifier for strings like there is in printf</code> proper. Fortunately, Unix tools to the rescue! cut</code> is generally used for splitting lines on delimiters, but the -c</code> argument will select a range of characters. So you can just do > cmus-remote -C "format_print '%a - %t'" | cut -c-60 Godspeed You! Black Emperor - A Military Alphabet (five eyes</code></pre> and while the unbalanced parenthesis is kind of visually offensive, and an ellipsis might be nice, it's good enough to use. Until I noticed that while I was listening to the FFXIV soundtrack, sometimes the status bar wouldn't update when I changed songs. Looking at the waybar output showed me this error: (waybar:2854654): Gtk-WARNING **: 11:04:07.422: Failed to set text 'Masayoshi Soken - Voidal Manifest / ヴォイドの棺～\xe9\xad' from markup due to error parsing markup: Error on line 1 char 69: Invalid UTF-8 encoded text in name — not valid “Masayoshi Soken - Voidal Manifest / ヴォイドの棺～\xe9\xad” </blockquote> At first I thought this was a weird encoding error, since if I remember correctly the ID3 information was originally in Shift-JIS and I had to do some hackery to get them into UTF-8. But it wouldn't make sense for only some songs to have this problen. And then I realized that's not actually 60 characters: > python3 -c 'print(len("Masayoshi Soken - Voidal Manifest / ヴォイドの棺～"))' 44</code></pre> The conclusion is that -c/--characters</code>, despite saying it operates on characters, and despite the presence of a -b/--bytes</code> option, actually operates on bytes. And sure enough, the documentation on the GNU website</a> says: Select for printing only the characters in positions listed in character-list. The same as -b for now, but internationalization will change that. </blockquote> This isn't present in the manpage (at least, not on my install), but it is in the info</code> page. And since I never check the info</code> page (does anyone?), I had no clue. Hilariously, there's a -n</code> option to not split multi-byte characters... but it's a no-op. As far as I can tell it's for compatibility with BSD's cut</code>, which does support this, and it looks like it even actually implements -c</code> correctly (since it has no mention of internationalization bugs, and explicitly says the behavior depends on locale variables). Disappointment</h3> I figured someone had already reported this to GNU, so I looked. I found this bug report from 2010</a>. In it, someone mentions that several distros have patches to fix this, but they duplicate code and/or slow it down on the single-byte locale case. Someone else adds that We're working on it. Something is coming soon. </blockquote> There hasn't been any activity since then aside from changing the severity and title. This collection of bugs across GNU coreutils</a> shows this has been going on for a while. I'm not sure if any of those bugs have been fixed, or if anybody's written partial support coreutils. But, honestly, it's 2021. GNU coreutils is supposed to be the solid foundation of Linux; I see people talking all the time about how powerful these tools are. And they break as soon as you give them anything that isn't a single-byte encoding... which, in the era where UTF-8 has become the dominant encoding and emojis are common, is going to be a lot of text. You can hack around this by using iconv</code> to convert your input to UTF-32, which will have four bytes for every character, and then back afterwards. And GNU awk</code> will just do the right thing automatically if your locale is set up right: > echo "ヴォイドの棺～" | awk '{ print substr($0, 0, 4) }' ヴォイド</code></pre> But it's still extremely silly that this is a thing you have to do. It's not 2000 any more; the world is Unicode and UTF-8 now, and you can't get away with assuming single-byte encodings in general-purpose tools. So if you're doing text processing, unless you're sure you'll never run into multibyte characters, don't use GNU cut</code>. Use awk</code> or something else instead. Eight Months of NixOS 2020-11-02T00:00:00+00:00 About 8 months ago, I decided that I'd gotten tired of macOS. It's a Unix, which is nice, and I like that I can set up things with relatively minimal effort through Homebrew, but I wanted something that actually gave me more control over my system. So I decided that 2020 was going to be the Year Of Linux On Ash's Laptop. In addition, I decided to try out NixOS</a>, which is an operating system oriented around the Nix package manager. The big thing that distinguishes Nix from other operating systems is that it lets you manage your packages declaratively: you specify what you want the state of your system to be, then run sudo nixos-rebuild switch</code>, and it reconfigures your system to be in that state. I also decided I would use home-manager</a>, which lets you do the same thing for your dotfiles. As is tradition, I also decided to version my dotfiles</a>, though they're still kind of a mess. the good</h2> hardware support</h3> I bought a used Thinkpad T450s off of eBay, because I wanted to make sure I had good hardware support, and the Thinkpad line has historically had a reputation for things working out of the box. And everything has worked fine: Bluetooth, wireless, even the touch screen (not that I use it). I didn't have to hunt down any weird driver repositories or modprobe anything into my kernel. The one thing I haven't tested is the fingerprint reader, because I don't trust it to be secure, so I never set it up in the first place. I did run into one issue: when I bought a replacement battery off eBay, Linux was having trouble recognizing it and reading its status. I had to do some kind of magic dance to reset something or another: I think it was 'pull the battery and AC adapter, hold the power button for 5 seconds, then plug it back in'. But once I did that, everything was fine. declarative package management</h3> This was the reason I specifically wanted to use NixOS in the first place. I liked the idea of having my system's configuration explicitly written out, and not just determined by whatever series of packages I happen to have apt-get installed. And NixOS delivers; my nixos-config repo</a> contains not only my dotfiles, but a list of all the programs I have installed, my fonts, and so on. I also don't have to worry about having accidentally installed something weird and then forgotten about it; whatever's not in my /etc/nixos might as well not exist (though it can still leave stuff in ~/.config and similar places). I intend to eventually switch the server this blog is hosted on over to NixOS for similar reasons, and I'm definitely looking forward to being able to declaratively manage things like nginx configuration and systemd scripts as opposed to scattering them all over my filesystem. customizability</h3> I've got everything set up the way I like it. I decided to finally give tiling window managers a shot, and after using awesomewm</a>, I don't think I could go back to having to arrange all of my windows by hand. Even on a laptop screen, I like putting my messaging applications (Discord, Telegram, IRC) side-by-side. And of course, having purpose-driven workspaces is nice. Instead of hunting down my music player in a window switcher, I just hit Win-6</code>, since I always keep cmus</code> on the 6th workspace. I've also got bars set up to display things like my upcoming todo count, my CPU usage, battery life, currently-playing music, and so on. I could certainly have done this on MacOS using Übersicht</a> or something similar, but it feels intuitively 'cleaner' in some way to be doing this in an operating system set up to have this kind of flexibility in the first place. the not-so-good</h2> the nix language</h3> The Nix package manager uses its own language, which is also called Nix, to define how packages work. The language is functional in the style of something like Haskell or the ML family, but lacks a lot of the niceties those languages have like a strong static type system or a means for doing imperative stateful programming. I ran into this when I was trying to generate a configuration file by iterating through a list and having the callback update some amount of state; Haskell has the state monad, but Nix has no such thing. This is especially salient because Nix does not follow the standard Linux filesystem hierarchy; it stores almost all of its libraries and binaries under /nix/store</code>. This means that you can have multiple copies of something installed without them interfering with each other, but it also means that you need to know how Nix packaging works to compile anything. Even libc isn't in its usual place, so downloading prebuilt binaries usually won't work. Fortunately, packaging simple software generally just involves telling it how to fetch it and what its build dependencies are, but figuring out how exactly to do that and how to integrate it into the rest of your configuration requires reading documentation. Which brings me to the next point: extremely sparse documentation</h3> Even though the Nix language itself is fairly simple to understand, the way in which Nix puts everything together can be... obtuse. For example, each package in the nixpkgs monorepo is implemented as a function</a> (here, the {stdenv, fetchurl}:</code> syntax at the top means that the file declares a function that takes a record with two fields named stdenv</code> and fetchurl</code>. However, when defining my own derivations to include in my personal configuration for programs not packaged by Nix, instead of defining a function, I just wrote out the derivation by hand. The difference to me wasn't obvious, until I did some deep digging and learned that behind the scenes, the nixpkgs repo invokes callPackage</code></a>, which invokes the function with the relevant arguments. Even just writing those packages involved searching the nixpkgs repo for similar programs and then copy-pasting what they did. The official NixOS wiki</a> has basically similar recommendations, and I found the NixOS manual to not be super helpful here. I wound up making heavy use of the Nix Pills</a>, which are a series of posts that show you not only how Nix package management is implemented, but why it works the way it does. Similarly: some commands are invoked like nix run</code>, some are nix-shell</code>. I don't know why. would i recommend nix?</h2> Only to power users. If you're going to use it, you're going to have to deal with the packaging stuff at some point, either to debug a package or to use software that doesn't have one. And this means you'll need to learn the Nix language, and wade through the nixpkgs monorepo and some fairly iffy documentation. But if you can put up with that, the 'everything is declarative' setup is exactly as nice as I hoped it'd be, and I've had multiple instances where an update broke something so I was able to just boot to an older generation. Similarly, when the BleedingTooth vulnerability came out, I was able to disable my Bluetooth stack with a one-liner in /etc/nixos/configuration.nix</code> to just blacklist the entire hardware support and then when the kernel updates came out I was able to just remove that single line as opposed to trying to remember where the fuck I'd stored that definition. action items for the nixos community</h2> Better documentation. Stuff that covers "I have a piece of software that's not packaged, how do I package it locally". Or "the software in nixpkgs is broken in some way, I'd like to test out some changes to the package definition, how do I set up the overrides for that". That sort of thing. A lot of this is covered on the wiki, so the usual WP:SOFIXIT</a> applies, but this is the sort of thing that I think should have already been written.</li> Faster switches for trivial changes. The big reason I don't manage my .emacs.d via nix is that it means that even a trivial change requires me to do the whole sudo nixos-rebuild switch</code> dance, which can take 20-30 seconds just to make a one-line change. This kills my iteration velocity. There are workarounds like having a 'staging' file that gets sourced and then every so often moving code from the staging file into the main file, but that seems like a workaround for a problem that shouldn't exist.</li> Some kind of lockfile to store package versions. One of the bits of state that isn't stored in /etc/nixos</code> is what version of the nixpkgs and home-manager repos I'm currently on. This means that if I run a switch --upgrade</code>, there's no way to go back without rolling back those channels via nix-env</code>. On the other hand, if those versions were stored alongside my nix files, then I could just revert them in case of a bad upgrade. My understanding is that flakes</a> are an upcoming feature that solves this problem, among others.</li> </ul> final thoughts</h2> Overall, I've definitely enjoyed the switch to Linux, and I can't see myself going back to macOS any time soon. I may wind up buying a more powerful laptop at some point, since this one is having problems with driving a 2560x1440 monitor due to a low fill rate on the graphics card, but I want to reduce my electronics waste footprint (hence why I bought this one used), so I'm going to stick with it for at least a few more years. I'm also probably going to stick with NixOS, but I hope it becomes better documented and more newbie-friendly. Right now, I'd hesitate to recommend it to anyone who wants something that just works and isn't interested in diving into the guts of their system or learning a new language just to install software. This Is How You Overcome Internalized Shame And Judgment By Reading 'This Is How You Lose The Time War' 2020-03-31T00:00:00+00:00 (This post is going to have some amount of spoilers for This Is How You Lose The Time War, so if you don't wan't to be spoiled on that, stop reading here. It's a fantastic book, promise.) I grew up, in a sense, on the Something Awful Dot Com forums. It's inarguable that if I hadn't been there, I wouldn't have met some of the people I did, I wouldn't have developed the political opinions I do, I might've not ever realized that I'm a girl. I might've fallen in with 4chan or some other god-awful site. But I definitely wouldn't recommend it to anyone, because it left me with a vicious streak a mile wide when it came to making fun of other people's creative work. I used to love tearing down the output of amateur authors or artists, even the ones that were just writing or drawing for themselves and hoped the rest of the world might like it. I'd never even intended to publish it, but when I do something, I want to do it well, and the self-criticism feeds on that. So, naturally, when I decided that I wanted to start writing, I ran into a problem. Even though I'd realized SA's utter toxicity several years back and had stopped paying any attention, I still had that voice in the back of my head, telling me that everything I wrote wasn't Good Enough. That I should be ashamed to even think of publishing it someplace where someone else could see it. And 'worst' of all, that it was 'too self-indulgent'. Because I like writing stories with happy endings, stories with robot protagonists</a>, stories with trans female characters that get what they want. On some level, of course, I knew there wasn't anything wrong with that: when I read something from an author I liked, I didn't feel that same sort of shame at their work. But the published authors I read that had fiction that took place in that same high-tech utopia tended to write heterosexual romance, if any. I love Iain M. Banks and his Culture works, but I can't think of a single hint of gay attraction in that entire series. And that inner critic just wouldn't shut up. My writing was bad, it was escapist bullshit, infantile, people would make fun of me and they'd be right to do so. It sucked. I wrote anyway, somewhat, but it definitely put a huge dent in my creative impact. I was constantly editing myself as I went, because nothing ever felt like it was good enough. And even worse, I was editing other people's work as I was reading it, thinking about how bad some word choice was, how I'd do things different, how I'd do things better. (Yes, I'd both think that I'm an awful writer and that I'm way better at writing than other people. Depression and impostor syndrome don't have to be rational.) Then, one day, my girlfriend gave me a copy of This Is How You Lose The Time War as we were walking through a bookstore. It's a book about two time-traveling agents from alternate versions of the future: Red is from the Agency, all machine perfection. Blue is from the Garden, a holistic bioengineered paradise. (You can imagine which one I prefer, of course). They start tracking each other through their time-traveling war, and leaving each other letters in ways they hope their handlers won't find: the bubbles of water in an MRI machine, the guts of a slain bird. My girlfriend had read it before me, and from her reactions I could tell she loved it. So I started reading it, and holy shit. Purple prose love letters, luxurious descriptions of powerful technology we can only begin to imagine. Either one of the protagonists could easily smash a tank bare-handed. For someone like me that has daydreams about being an invulnerable combat robot, it was like catnip. Not only that, but Red and Blue completely fall for each other over the course of the story. And unlike so much of the WLW stories I'm used to in media where I have to settle for a smirk and a half-glance and a 'what-if' in my head and in fanfiction, they actually confess their love to each other. They talk about how much they want to be with each other, how much they love each each other, and so on. It's an actual explicit love story! And as I was reading it, I realized: this is exactly the sort of self-indulgent stuff my inner critic would chastise myself for writing it if I wrote it. And yet here it is, an actual published book, (a Nebula finalist even!). Sure, my prose isn't as good as Time War's, but the concept is something I'd absolutely write, something I'd love. And of course I'm not as good of an author as actual, professional, published authors; it'd be an insult to them to think that I would be! And so my inner critic actually shuts the hell up for a moment and lets me work. I don't want to make it seem like this has magically fixed everything, of course. My creative output's still slow. This shame wasn't the only thing holding me back; I still have motivation issues, ADHD, and a host of other bullshit. Writing is still a hard thing to get done; even writing this blogpost has taken me over a week, when it "should have" only taken me a couple days. But I've been shutting down that inner critic every chance I get, and I've been helping my other girlfriend write a story about a combat robot rescuing her amnesiac human-disguised girlfriend off ancient Earth</a> over the past few months. She's been doing all the pen-to-paper work, but I've spent hours and hours plotting it with her. And if I hadn't read Time War, if I hadn't dropped off so much of my shame, that work would be a lot harder.

postscript</h2>
While looking things up for this article I found this Wired article from 2010</a> making basically the same argument I am here. Ah well.</p>

responding to HN</h2>
This section added 2022-10-01 22:25 PDT. I don't use Hacker News myself, and rather than effectively leave part of this post in the comments section of an unrelated website, I thought it'd be good to address points here.</p>

Overall</h1>
If it wasn't for the coil whine and my lingering concerns about the build quality, this would be great</em>. If you're not as sensitive to coil whine as me (because you can't hear it or you just don't care), I'd totally get one. If you are... maybe not. Hard to say.</p>

gay robot noises - /var/log/ash

Obligatory AI Opinions Post

conclusion</h3>
AI is a land of contrasts.</p>

An actually useful definition of 'slop'

I am tired of the word 'techbro'

Type-level Bounded Recursion in Rust

It's Just Not Desktop Ready

Creating a Wayland protocol so a cat can chase my cursor

I forgot my full-disk encryption password :(

Don't believe the 'biological intelligence' hype

An elegy for GNU and RMS

Comfy Software

System76's Lemur Pro 10: A review

Announcing sub-rosa 1.0.0

cut -c considered harmful

Eight Months of NixOS

This Is How You Overcome Internalized Shame And Judgment By Reading 'This Is How You Lose The Time War'

gay robot noises - /var/log/ash

Obligatory AI Opinions Post

conclusion</h3> AI is a land of contrasts.</p>

An actually useful definition of 'slop'

I am tired of the word 'techbro'

Type-level Bounded Recursion in Rust

It's Just Not Desktop Ready

Creating a Wayland protocol so a cat can chase my cursor

I forgot my full-disk encryption password :(

Don't believe the 'biological intelligence' hype

An elegy for GNU and RMS

responding to HN</h2> This section added 2022-10-01 22:25 PDT. I don't use Hacker News myself, and rather than effectively leave part of this post in the comments section of an unrelated website, I thought it'd be good to address points here.</p>

bus factor</h3> Volundr says:</p>

Comfy Software

The pillars of cozy software</h2> In my opinion, the pillars of coziness (in no particular order) are:</p> Customizability</li> Keyboard-focused navigation</li> Non-corporate governance</li> Good documentation</li> Make the common things easy</li>

System76's Lemur Pro 10: A review

Overall</h1> If it wasn't for the coil whine and my lingering concerns about the build quality, this would be great</em>. If you're not as sensitive to coil whine as me (because you can't hear it or you just don't care), I'd totally get one. If you are... maybe not. Hard to say.</p>

Announcing sub-rosa 1.0.0

cut -c considered harmful

Eight Months of NixOS

This Is How You Overcome Internalized Shame And Judgment By Reading 'This Is How You Lose The Time War'

conclusion</h3>
AI is a land of contrasts.</p>

responding to HN</h2>
This section added 2022-10-01 22:25 PDT. I don't use Hacker News myself, and rather than effectively leave part of this post in the comments section of an unrelated website, I thought it'd be good to address points here.</p>

Overall</h1>
If it wasn't for the coil whine and my lingering concerns about the build quality, this would be great</em>. If you're not as sensitive to coil whine as me (because you can't hear it or you just don't care), I'd totally get one. If you are... maybe not. Hard to say.</p>