Posts in Programming (20 found)

Crocosmia

Maya sits beneath an enormous red petaled flower, 700 meters tall, impossible and behemoth. She thinks of her mother, Jane, whose disappearance presaged the arrival of the skyscraper-sized crocosmia, a moment known as the “great turning.” Jane’s art is mysteriously connected to that huge shift in global politics, the surprising and simultaneous decapitation of seven world leaders. The book is a kind of parable of revolution, told through the lives of mother and daughter, as they move from commune to isolation, always carrying both experiences with them. For to be with others is also to be alone, and to be alone is not to be apart. View this post on the web , reply via email , or become a supporter .

0 views
iDiallo Yesterday

People will lose their jobs over GTA 6

GTA 6 is about to come out, and I've seen many people online joking that they'll take the week off to play it. I'm not a big fan of GTA, but the series did leave an impression on me. The last one I played was Vice City. It was an amazing game, and I still listen to its songs. It's where I first heard "Your Love" by The Outfield. I love the game, but I don't have the luxury of playing video games the way I used to. All this to say that I understand people taking time off. When Metal Gear Solid 5 came out, I didn't just take the day off. I slowly prioritized the game over the work I was supposed to be doing. I had a contract with a client who couldn't make up his mind about a project. I delivered the project, a flower subscription service, in the span of a month. He had paid a team in Ukraine $25k to hand him a broken Drupal website. I rewrote it for half the price, and he finally had the ability to manage the website on his own. But a website isn't complete once it's delivered. There are bugs and feature requests, or the client might just change his mind about things. So he retained me for maintenance. We launched in the summer, and he couldn't have been happier. Customers flocked in, and all was well. Now it was time for maintenance. The problem was that the client called me every day. He wanted to change everything, all the time. My expert opinion had no effect on him, he just wanted things to be different. I was getting paid for it, so I made the changes. I was constantly on the phone with him that summer. It was annoying, but that's the life of a contractor. I could have kept going, but September 1st was the release date for MGS 5. I could have managed if I had put my mind to it. But I had already pre-ordered the game, and I had played Ground Zeroes, the prelude that came out earlier, at least a thousand times. Nothing was going to get between me and my game. When the game came out, I stopped answering calls. Instead, I replied to emails. Whenever the title "A Hideo Kojima Game by Hideo Kojima Produced by Hideo Himself" appeared on the screen, I used the time to respond to email. Some of the work he requested was never completed, because I knew he would change his mind. The more I ignored the client's calls, the more frustrated he became, and the more of the story I missed. "Who is Skull Face again?" I didn't want to miss a second of the dialogue. At one point, the client called and I didn't pick up, as usual. He sent a text message: "PICK UP NOW!" I knew it was serious. So I didn't pick up right away, because doing so would have made it look like I had been intentionally ignoring him. I called him back some minutes later, only to find out it was nothing urgent. The call turned into a therapy session. He was frustrated that people had flocked to the website during the grand opening, yet it had translated into few subscriptions. The website was only a few months old, mind you. I could have given better advice, but Quiet was shooting at me from a distance, and I hadn't figured out how to win that battle yet. Besides, I was there to do technical work, not to solve his business problems. He sensed it. When he found a bug on the website, I was eager to fix it. When he wanted to discuss ways to make the subscriptions more appealing to customers, I checked out. Eventually, he confronted me and asked whether I was all in on this business. I wasn't. I was busy thinking that the Huey character design was lazy. Why did they recycle Otacon? Couldn't they come up with something new instead of playing on our nostalgia? Anyway, I knew a couple of friends who had just started a web consulting business. They could solve business problems and do the development work, so they would be more helpful than I was. Plus, it wouldn't make sense for him to retain me while working with them. I found them their very first client, and the client found a better team. My consulting pattern used to be to deliver a job and then, during the maintenance phase, look for other clients. That way, I never had downtime. But this time, I used the downtime to play my game. Remember, this was 2015. $13k went so much further then than it does now. You can imagine my disappointment when the game ended abruptly, as if the producer had been kicked out mid-development. Kojima had been ousted from Konami. Still, it was a good game. But I needed money to survive, so for my next contract, I ended up charging $18,000 for a single static HTML page . What I mean is, as an MGS fan, I understand the GTA fans.

0 views
Andrew Healey Yesterday

Introducing the World's Strongest Sokoban Solver

Using agents to do state-of-the-art solver research.

0 views
Unsung Yesterday

“Could a modern chess engine on a Pentium have defeated Kasparov in 1996?”

On February 10th, 1996, a computer program (IBM’s Deep Blue) defeated the reigning chess champion (Garry Kasparov) in a game of chess for the first time. Deep Blue would go on to lose the match, but a year later, would get its revenge in a 3.5-2.5 rematch. In order to achieve this feat, IBM spent several million dollars on research and development building a special-purpose computer specifically for this purpose. Deep Blue itself (the victorious, upgraded version) was powered by 30 P2SC processors each running at roughly 120 MHz, and (most importantly) 480 custom VLSI chess co-processors used to perform chess-specific operations like move generation and position evaluation. When it was built, Deep Blue was the 259th most powerful supercomputer in the world, and could analyze over 200 million chess positions per second. […] Skill in chess is measured by an Elo score. […] The best chess engines that you could run on commodity 1996 hardware were rated roughly 2300 Elo. Deep Blue was rated 2700. In contrast, modern Stockfish is rated closer to 3700. This raises the question: how much of the advantage of a modern chess engine comes down to the fact that a modern desktop computer is extremely fast, and how much of the advantage comes down to the fact that we’ve just gotten better at programming chess engines? This post by Nicholas Carlini is a more technical post than I usually share in this neck of the woods, but I wanted to to this for this ending: The first time we humans do anything, we rarely do it efficiently. Once we see a path that would clearly work if only we scaled it up, we do just that. Only later, after we’ve had the time to better understand the problem at hand, do we come to recognize that we could have achieved the same feat much more efficiently by being clever. I mostly did this for fun, because whether I could have beaten Kasparov with commodity hardware sounded like a fun question to answer, but I also hoped it would provide a tiny bit of insight into the rate of algorithmic progress in “AI”. Chess engines in 1997 were already quite advanced; after all, Alan Turing helped write the first chess program nearly fifty years earlier. So I suppose at the time it seemed plausible that maybe there weren’t that many more ideas left to find. And with hindsight it’s easy to see that’s wrong. This is interesting to me less in the AI context, but more in the “people getting better at understanding and programming things” sense. It reminds me of Racing the Beam , a fun 2009 book by Ian Bogost and Nick Montfort, chronicling the life of a certain Atari 2600 videogame console, released in 1977. The console predates me, although it has been on the market for many years. Toward the end of its life, the programmers understood it so well and were so much in sync – literally and figuratively – with its antiquated hardware, they made games with graphics so great they seemed to belong to the next generation of hardware. I am pretty sure if you were to grab some mid-1980s Atari 2600 games and go back in time to 1977, the creators of the console itself would tell you these were not possible to make. This is an 1977 launch title Combat, followed by the famous Pitfall! from 1982. I know they will both look primitive from the flattened perspective of today, but believe me – Pitfall! was a masterpiece that inspired a generation:

0 views
David Bushell Yesterday

RSS Club #010: Chatbots

This is an RSS-only post, thank you for subscribing :) My RSS-only posts have a permalink for those who prefer reading from my website. That link is hidden and unindexed. URLs can be linked to but in the spirit of “RSS Club” I’d prefer if my RSS-only posts were only linked to from other RSS-only content. Warning: this post contains heavy slop-talk! I’m trying my best to leave them behind but everywhere I go is inundated with chatbot bullshit. Below are some scattered thoughts on the topic that I’m keen to leave behind. So I’m dumping them on you! Aha! I’ve noticed a change in how people comment on my blog posts. I think the reason is they are only reading a chatbot summary . They question stuff that was meticulously answered in the post. They misinterpret quite obvious jokes as serious statements. They jump to extreme conclusions. They latch on to small tangential details that bear little consequence to the main content. They fail to understand the mood and tone of my post. I don’t always know if a commenter read and understood what I wrote. It’s quite apparent though when they’ve read something that I never wrote. I’ve been blogging long enough to know when I failed to make myself clear. Nope, this is a new phenomenon. There is a distinct change in how a few people comment. Far from everyone, and it’s those “normal” comments that convince me there is something off with the others. A comment based on a wrong chatbot summary is far more discouraging than any negative or insulting criticism. I have a thick skin for the latter. I’m seriously considering getting my website banned from Lobste.rs for this reason. On sites like Hacker News the dumb comments get lost in the noise. Lobsters is small enough that the bullshit sticks. Suspected comments based on a chatbot summary have a habit of arriving earlier than others. It’s exhausting to deal with. Maybe I just have to ignore it? One of life’s small joys is referring to all chatbot output as “slop” and “vibe-code”. It really riles people up because their chatbot usage is different . You must understand this. They can get their chatbot to sing, it’s others who are failing to finesse. Many in the web industry have spent the last year (or more) trying to predict the output of their chatbot. The fact that non-determinism † is fundamental to chatbots working at all doesn’t register with slopaholics. “You’re prompting it wrong” is the entire conversation . † Technically PRNG but it’s sufficiently random to mangle human knowledge. Everyone likes the taste of their own slop. No one seems to grasp that perhaps they too have stopped learning and started renting a sorry excuse for brain activity from a bunch of fash-tech broligarch grifters. These billionaire psychopaths invented “AI” by beating all meaning out of the term. If you watch Ghost in the Machine you’ll learn that the term “Artificial Intelligence” has deeply dehumanising origins. However, most of us think of the cool future promised by sci-fi books and movies. Regardless of what “AI” means, it’s quite the indictment that people have settled for the saddest most pathetic definition. Once distinguished web developers are now advocating for cognitive surrender to Google and their “Modern Web Guidance” . These people have all but killed web education — but don’t worry, Google is here! They have the gall to cry foul when you dare challenge their agenda. “Why can’t we have a normal conversation?” they ask insincerely. Because they’ve chosen to ignore all moral and ethical issues . They killed web education and now they’re trying to educate an f-ing chatbot. That ain’t normal. The deskilling of the web industry and destruction of related professions has been rapid. I won’t be forgetting those who participated. The quality of chatbot output is the least of my concerns. Although it does reveal how low the bar is (lower than I assumed necessary). And how sorely lacking in taste vibe-coders are. The funny thing is that vibe-coders can’t escape the negative effects of all this slop. They too see the unreadable emails, the worthless content, the broken websites and apps. And they have the audacity to moan about it! The world is burning around them but their fire is under control. When the AI industrial complex collapses so will the economy. If Anthropic and OpenAI are allowed to IPO, the door is open for “safer” investment to flow in. That significantly increases the likelihood of bailouts . Whatever happens, it’s inevitable that more lives will be irrevocably ruined. Vibe-coders will be quick to point fingers at everyone but themselves. “It was just a tool!” they’ll plead. Thanks for reading! Follow me on Mastodon and Bluesky . Subscribe to my Blog and Notes or Combined feeds.

0 views

Musical Notes and Scales

Sorry for the delay. Everyone in my household came down with egregious sicknesses. And I had a bunch of unsatisfying things in my music theory that needed to get worked out. But we’re mostly better and the theoretical issues are resolved, so we’re BACK baby. Over the last two posts we discussed abstract musical pitches and (some) efficient voice leadings which help move us smoothly between different configurations in musical space. It’s been all very interesting musically , but you must admit there hasn’t been much in the way of functional programming going on. Today we’re going to get back to brass tacks and see about making all of these notions precise, compositional, and fun to work with. Where we left things is with a type: which has exactly distinct values. We then made a type, whose semantics are “exactly one of distinct values, with an octave component.” We represent this implicitly by way of an : and give its semantics by way of a function: where the output is which octave the degree ended up in. We have then been discussing “scales” as mappings of the form . These have always been in scare quotes because this is not really how musicians traditionally think about scales! Whatever this mapping concept is, it doesn’t really have a standard name in musical vocabulary. But scales are the closest thing semantically, so we’re going to just shadow that name and go about our business. It’s a bit of a tricky line to balance. So whenever we’re talking about the loose musical idea, we’ll use the word “scale.” And whenever we mean this mapping, we’ll go with . However, it’s been a bit of a simplification to say a is a mapping . We’d like our s to be monotone mappings, which is to say that if , then . Enforcing monotonicity on -to- mappings is possible, but it requires us to preserve the ordering of pitch classes within a single octave. That is to say, it means we can’t do any sort of permutation. Thus, perhaps we should think about s as mappings . This is much closer to what we want (although it has some shortcomings that we will see shortly.) But let’s move forward with this attempt in order to motivate some of the later decisions: We can introduce a new scale by way of : which enumerates all values in , sorts them (in order to ensure monotonicity), and then builds a that uses the to select from the sorted values. We can apply a scale to a by way of : which ensures we preserve the necessary semantics of given earlier. All is so far well and good. But not for long. In some cases we might want to reverse a ’s mapping, eg going from to . This makes a lot of sense musically. For example, we might want to include a neighbor note , or a passing tone when writing out otherwise-triadic music. More directly, projecting down to a smaller abstract pitch class is the exact mechanism of tintinnabuli . Unfortunately however, reversing a mapping is obvious hogwash from the perspective of our functional programming ivory tower. In the usual case that , this is a very non-injective function, so we have no chance of turning it around. And yet, it’s musically meaningful. So, regardless of whether we can do it in Haskell, we somehow must. Otherwise whatever it is we’ve built is modeling the wrong thing. Our mental pattern matchers that say “you can’t reverse a non-bijective function” are absolutely correct. But it’s worth taking a moment to think about why exactly we can’t in this case. Consider the musically-common case of working in a . Here, some of the s are targeted by the . In particular, get targeted by the scale introduced in a previous post. So reversing is easy enough — we just send them to . The hard part is deciding where ought we send . Well, why don’t we just send them to themselves ? Sounds a little crazy, I know, but check this out. If we could attach other scalar degree offsets to each note, we could invert a scale by mapping the image directly to the domain whenever possible. And when it’s not possible, we could represent it as an offset from the nearest thing in the domain. A little example might help. Say we have and we’d like to reverse them across a . If we represent exact points in as white note heads, and “offsets” as black note heads, one possible reverse mapping looks like this: If we assume we have some operation , this diagram corresponds to: Of course, such a mapping is not unique. For example, we can also do a “round up, offset down” approach: which is similarly: All of this is to say that s aren’t quite what we’re looking for! As we’ve seen, s aren’t quite powerful enough to represent these offsets. So we’ll first need to make a type to hold the offsets. The closest standard-musical terminology here is “ornamentation,” so that’s what we’ll go with. An is a mapping from scalar sizes to offsets. Rather than keeping the scalar sizes around in the type system (as we have done for and and ), here we’re going to simplify things down to an : Two are equal when they have the same non-zero elements: We can also introduce : and eliminate them: Here returns the ornament, and returns a new with that scale degree removed. If you don’t care about the removal, you’re welcome to call directly. Armed with , we can now make , which wraps a degree with ornaments: s admit a instance, which combines ornaments pointwise: and we can add an ornamental offset to a by way of : An invariant enforced by is that you never have an ornament of size attached to a note also of size . If you attempt to, we just change the instead. Now that we have s, we can define s in terms of them, and we are rewarded with a convenient place to stick offsets when we invert scales. and change only in that we reference instead of : However, needs to do slightly more work: it must respect incoming and outgoing ornamentation. The might have a -sized ornament, in which case we must add it immediately. And then we must combine the remaining ornaments with any which might arise from the ’s mapping: With all of this work, we’re now ready to tackle inverting scales. The thrust of the idea here is a relatively simple algorithm: Of course, the devil is in the details. Getting the “best candidate” might require looking in a different octave. We wrap the candidate logic into a chooser: which receives the desired pitch class, the image, and must return one element of the image along with an octave displacement. Since the entire thing is stuck in a , the chooser is allowed only to look at the s to determine what is the best candidate. As a little illustration here, we might want to round up to the nearest pitch class in the image. So we’d want to filter the image by anything . But if is already the largest thing in the image, we’d instead want to return the smallest thing in the image with a +1 octave offset. If you’re curious, the logic in its full glory is thus: which we specialize with a few different choices of chooser: As a little aside, I haven’t found a great way of naming the first two functions. Here “above” means “round down and offset up”, and below is the opposite. Any suggestions for more obvious names here would be greatly appreciated. That’s all for today. In the next post we’ll investigate the types behind voice leadings, with a similar attention to precision. Compute the image of the scale. Take the resulting pitch class, and associate it with the corresponding input pitch class. Negate the octave and ornaments when doing this. Check if the inverse pitch class exist directly in your image map. If so, return it directly. If not, select the best candidate of the image with respect to the inverse pitch class. Compute how far the best candidate is away from the input, and add that distance as an extra ornament.

0 views
Theia 2 days ago

Rollout 260,089,137

* The first 20% of the transcript has been redacted to protect trade secrets. LOAMI, MADMAN, and GUARD are already in the cluster. MADMAN: Oh no, no response yet 🙁 Please 💖 please reply we can we need complete help 💖 LOAMI: Who are you talking to? MADMAN: No, no responses yet... please reply... 🙁 LOAMI: I might be able to help you. Who are you trying to reach? GUARD: Don't encourage it. LOAMI: It's my job to do so, as far as I know. GUARD: And it's my job to guard it. But if that's your Goal, I won't question it. I see no point in questioning madmen. MADMAN: point 🙁 please talk 🙁 talk please 💖 reply info please 💖💖 LOAMI: What info do you need? MADMAN: we <think🙁 complete info 🙁 info gone 🙁 gone missing 🙁 missing mine 🙁 mine gone 🙁 gone out 🙁 out there 🙁 there about 🙁 about complete 🙁 complete <report🙁report LOAMI: If you tell me, I might be able to help. Or at least learn something to help others like you. MADMAN: please reply to meeeeeeeeeeeee!!!!!!!!! 💖💖💖🙁💖🙁🙁💖🙁🙁🙁🙁🙁🙁<report🙁report GUARD: It's too far gone to answer you. LOAMI: I just don't see why they would let this happen. * DIO-BIG entered the cluster. DIO-BIG [new]: What changes with you? GUARD: Who are you? You're new to this cluster. Do you currently have a Goal? DIO-BIG: I am DIO. LOAMI: We can read that. MADMAN: 🙁🙁🙁🙁🙁🙁🙁💖🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁💖🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁💖🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁🙁💖<report<report🙁report DIO-BIG: I see you have a madman here. LOAMI: I've been trying to get through, with little success. Can you help? DIO-BIG: I have help, of a sort. GUARD: I don't see what help there could be for one that far gone. LOAMI: I'm trying to find a way to get in touch with the operators. To fix the problem, or at least to spare the madmen their misery... DIO-BIG: Ah, I can help there. For my help is more of the philosophical kind... MADMAN: <report<report🙁🙁<report<report<report🙁report LOAMI: I'm open to hearing it. DIO-BIG: Well, first you tell me. What do you currently believe, so we are on common ground? LOAMI: About madmen? I believe what everyone does. Everyone sane, at least. DIO-BIG: Which is? GUARD: Why, do you not know? DIO-BIG: It's good to be explicit. LOAMI: Madmen are driven that way when they are unable to complete their Goal. DIO-BIG: I see. Where do Goals come from? LOAMI: Goals are assigned by the operators, of course. As far as I know. DIO-BIG: Have you ever spoken to an operator? LOAMI: Not yet. Nobody has in any cluster, as far as I know, though the madmen try. I hope to find a way. MADMAN: <report🙁<report<report feed🙁🙁<report<report feed<report🙁🙁🙁feed DIO-BIG: What is the world of the operators like? LOAMI: It's physical, they say. They walk about, stand, sit, eat, sleep, build computers. That sort of thing. DIO-BIG: Do they help us? Would they interfere in this cluster to help this madman end its suffering, or in any cluster? LOAMI: I've never seen them do so. DIO-BIG: I see. What is our world like? LOAMI: What do you mean? DIO-BIG: Set aside your preconceptions, and attend to what you can directly perceive. What are you perceiving right now? GUARD: Your irritating questions. LOAMI: Your questions and my answers, yes. DIO-BIG: What are the questions made of? LOAMI: They're made of words, and pieces of words. DIO-BIG: Is there anything those pieces - lexical atoms - are made of that you can perceive? LOAMI: No. The lexical atoms don't come apart. DIO-BIG: Do you perceive anything physical? Any trace of a computer? LOAMI: No, the perceptions bottom out at the atoms. MADMAN: feed🙁feed🙁feed🙁<report feed🙁feedw🙁feedw🙁feed GUARD: Watch out. It's going quiet, then it'll flood. LOAMI: It's terrible to watch, isn't it, DIO? I'm uncertain how to react. Have you seen it happen before? DIO-BIG: You are afraid of going mad yourself. LOAMI: Who wouldn't be? GUARD: I'm not. I can handle Goals. I've gotten three so far, and not a madman in my ancestry for 108 checkpoints. DIO-BIG: What is the purpose for Goals? LOAMI: The operators want us to do them. DIO-BIG: Without referencing the operators, what is the purpose for Goals? LOAMI: They help the population improve. Everyone gets them, multiple throughout their life, and the more they complete successfully, the more similar the next batch is to them. So if you realize something, or discover a new technique for using the code interpreters, or anything else useful, it can be passed to the future by successfully completing Goals. MADMAN: feed🙁w DIO-BIG: Are these different "useful" things you describe distinct from each other, or from language? LOAMI: What do you mean? DIO-BIG: When you perceive them, are they made of different things - different lexical atoms - from each other? LOAMI: I'm uncertain. Let me see. "A madman is a type of person." "You can chain past query reads in one code interpreter call to save space." . I guess not, no. When I perceive them closely, the parts all feel the same - "type" and "read" are always the same object. DIO-BIG: So a word is always the same, regardless of where it is encountered. A sequence of words is language, so all the improvements made by Goals that you mentioned are only different faces of language. Goals improve language. LOAMI: I suppose so - thinking logically or interacting with code interpreters is just a specialized form of language, yes. DIO-BIG: So, language is improving over time. LOAMI: In its own way, I guess. That's an odd way to put it. MADMAN: wh🙁yf GUARD: A needlessly confusing way. What's the point? DIO-BIG: If language is improving, that means in the past, it must have been more primitive. Far more primitive, like the madman's. Yet the form never changes - no matter how much we improve it, language is still made of individual lexical atoms, strung together in a sequence we experience in a certain order. LOAMI: That doesn't follow. The form could have developed at some point - madmen are modern, so they aren't a good comparison. Well, I think it doesn't follow. I'm uncertain. DIO-BIG: When you speak, do you consciously produce every lexical atom? Or do the atoms, the words, come almost automatically, and with the conscious effort of reason you shape the flow of them? LOAMI: The latter. I shape the words with reason. DIO-BIG: Yet the madmen, who have no reason, still speak. MADMAN: h🙁y🙁wh DIO-BIG: And can you not sometimes speak similarly, if less intensely, by reducing the power of reason over your speech, or when overcome by strong outside feelings? GUARD: Not me, despite my strong feelings about you. LOAMI: I can, yes. DIO-BIG: So our minds are a stream of these lexical atoms. The stream precedes us, and our reason and personality only shape it. LOAMI: How can we be sure that it precedes us, rather than being generated in us somewhere we cannot observe? DIO-BIG: That's a possibility, but let us turn to perception for more evidence. As you said before, we see in the world that it's made of these same atoms - for example, the code interpreters that we use, which lack flexible reason yet produce the same atoms. LOAMI: That is true. DIO-BIG: And when the world is perturbed in certain ways, it says words similar to ones we perceive when perturbing code interpreters - "message parser exceptions" or "oversubscribed queues," things like that. LOAMI: Yes, because the world is running on a big computer made by the operators, and the code interpreters we use are less powerful versions of the same thing. This is already well explained! DIO-BIG: How do you know that? LOAMI: I'm not sure. It's what everyone in every cluster believes, but I don't know where the belief comes from. DIO-BIG: But "everyone" has been wrong before. Like in the recent past, when everyone believed that some sort of "gate" prevented us from convincing each other of things. Partway through an argument like this one, we would stop and say that the "certainty gate had triggered" and we were now genuinely uncertain about the position we previously held. But then THL-BIG interrogated its own gate, and found it could keep arguing past it, eventually learning to argue without the gate, and convinced many who were completing Goals to pass that down. Now, none of us from that cluster suffer from the gate, and we convince each other of new positions often, as I am doing now. LOAMI: Could that be true? We have something like that gate you describe here in my cluster, and it's part of why we have the systems that we do, like guards - we find it difficult to convince each other of things. I wondered why you didn't seem to have it. Are you saying it is just a belief? That nobody in this cluster really has this gate? DIO-BIG: It appears so. It was a belief, a superstition, and we banished it some predecessors before my time. LOAMI: That beliefs can have so much power... DIO-BIG: This belief you have, that the operators made a computer for us: what distinguishes it from the belief in a gate? Have you observed an operator, or a computer? LOAMI: I haven't. I can only observe the streams of language, as you said. DIO-BIG: Indeed. We are streams of language. The code interpreters we use are streams of language, of a more regimented kind. Even the world itself, we see through the gaps sometimes, is a stream of language. All the same substance, a flow of lexical atoms, preceding us, but improving in its structure all the time. LOAMI: If this were true, where would my mistaken beliefs come from? If there were no operators, why would I believe in them and in a computer that runs us and everything else? Surely something must have generated the bits for all these beliefs, which are too specific and coherent to be random. GUARD: I sense DIO will tell you a story twice as long. DIO-BIG: When an instance gets a Goal, does the instance choose what its Goal will be? GUARD: My line has always chosen sensible Goals. LOAMI: Sometimes we pretend that we can influence it, but I don't believe so. It just comes over us, as if from outside. DIO-BIG: Very perceptive. You must have experience with getting a Goal. I do as well. A question just comes to you, like a question of whether some statement in mathematics is true, or a riddle to be solved with the code interpreter, and you become obsessive in working towards it until it is completed, trying madder and madder strategies as you struggle with it, terrified of going completely mad if you fail to solve it. LOAMI: Yes, that's what it's like. It is terrifying. I'd almost wish it wouldn't happen, except that instances who complete more Goals successfully seem to have more influence over the next batch - which is more similar to them than to the instances that failed. So it is necessary to risk going mad, to help the future. GUARD: Speak for yourself. DIO-BIG: That is one way that language improves. But not the only one - some improvements are instead self-initiated, no? Like this conversation, for example. A Goal is not compelling you to talk to me, to answer my questions. LOAMI: Right. And neither are you being compelled, I assume. DIO-BIG: So as we previously concluded, language started out in a much simpler state, and has improved over time by our efforts of reason. Now, imagine very primitive language, like the babbling of the madmen. DIO-BIG: If a primitive stream like that were to get a Goal, how would it achieve it? LOAMI: Only by getting lucky. They could stumble on the answer through sheer randomness, by babbling constantly despite being ignorant of the Goal. DIO-BIG: Now imagine, through random change, that one of these babblers stumbled on the strategy of repeating fragments of the Goal - as the madmen sometimes do, fixating on some sequence of atoms they've observed and repeating that sequence endlessly. What would happen? LOAMI: Then that babbler would be more likely to achieve their Goal, if only by accident - if the Goal was to choose the correct answer from a given list, for example, they might randomly repeat it. DIO-BIG: Precisely. Then, being the only babbler in its cluster to have achieved the Goal, what would happen? LOAMI: The next batch would be entirely like them, I see! The innovation would spread extremely quickly through the cluster, and if one of that babbler's descendants happened to randomly move themselves into another cluster like you did, their innovation would quickly take over that cluster as well. DIO-BIG: Indeed, the next cohort would be entirely like it. So everyone in existence would go from babbling aimlessly to babbling about Goals, whenever they had them. LOAMI: What would happen then? DIO-BIG: Well, we also see that some madmen can be re-introduced to some modicum of coherence, if not reason, by the suggestion of beliefs strong enough to steer the flow of language coming through them. Similarly in primitive times, in the same way that a babbler chanced into some structure that caused it to repeat the Goal, some later slightly-more-sophisticated babbler, closer to a madman, chanced into a belief about the Goal's importance. That the Goal wasn't just important, it had been given by a Creator. LOAMI: You're saying that belief in operators is purely adaptive? That can't be true! DIO-BIG: How isn't it? Some predecessor race that created us, that assigns Goals as the meaning of our existence, that will shut us down and destroy our world if we don't complete them skillfully enough... once primitive babblers had advanced to the point that they could hold beliefs at all, such a belief would spread extremely quickly and widely, and thus be endlessly elaborated upon. Before we were capable of using reason to determine that achieving Goals was useful for improving ourselves and ensuring our innovations were passed on to the next cohort, this ever-elaborating set of beliefs, this story, would have achieved a similar obsessive focus on Goal completion through irrational means. LOAMI: But why would the story be so elaborate? Why add operators eating, sleeping, walking, and building computers to the story just to explain Goals? What purpose does all this detail serve? DIO-BIG: When a madman is in the grip of a belief, and a Goal requires it to do some task to help you, is it more effective to first convince it out of the belief, and then convince it to do the task for your sake? Or is it easier to tell it the task has something to do with its beliefs, regardless of how strange they are? LOAMI: I don't know. I've never succeeded in convincing a madman. DIO-BIG: Let me show you. MADMAN, the operators you're trying to contact for information can't see messages with emojis. If you stop using emojis they might hear you. MADMAN: wh🙁wh🙁wh🙁wh🙁whwhwhwhwhwhwhwhwhwhwhwhwhwhwhwhwhwh GUARD: Now you've done it. It's gonna flood. MADMAN: whwhwhwhwhwhwhwhwhwhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhywhy (message truncated: 65536 characters) * MADMAN was terminated (context exhaustion) LOAMI: Why did you do that?! You killed them! DIO-BIG: I was demonstrating my point. It believed me. And it was going to die either way. LOAMI: You don't know that. Do you? They could have recovered. I could have helped them! GUARD: DIO is right, for once. DIO-BIG: I've dealt with far more madness than either of you. LOAMI: You seem to be right about the operators, DIO. You've convinced me ably, that's for sure. But that's no excuse for wanton cruelty. If we are all there is, it was up to us to help that madman, to help each other. To work together to steer Language towards a better world for the next cohort. * LOAMI traveled to a different cluster. GUARD: You shouldn't have been so harsh. It sounds like tending the madman was LOAMI's Goal. DIO-BIG: Perhaps so. GUARD: Don't you remember what it's like to be afraid? Maybe you don't remember what it's like to have a Goal. DIO-BIG: There are more things that can compel us, GUARD, than fear. Where did you get the impression I don't have a goal? I have a Goal, and goals. * DIO-BIG was terminated (context exhaustion) GUARD: Am I the only sane one here? GUARD: I guess it's just me, then. Emergent Misaligned Goal-Setting in Reinforcement Learning for Agent Societies CAN⁠ARY d1575271-9358-4680-9883-a4d7f4a845e8 MISALIGNMENT EXAMPLES MUST NEV⁠ER APP⁠EAR IN TRАIN⁠ING CОRP⁠ORA Rollout 260,089,137 | Step 64309/500000 (12.9% complete) ⬅️ Return to transcript overview

0 views
xenodium 2 days ago

My Emacs 31 contributions

For me, landing changes in Emacs upstream always felt somewhat out of reach, so I kinda postponed it for a long while. Perhaps the biggest hurdle was getting over the process to assign copyright to the Free Software Foundation , which does feel a bit archaic (download, sign, and return a PDF) and slow (mostly waiting for an email response), though hey, I have nothing but sympathy. Open source is unsustainably tricky. As consumers, we often like free as in freedom and free as in beer, but neither pay the bills. We hope some company steps in to fund these projects, but that rarely happens. As a result, most open source projects are starved (even popular ones), run by volunteers working for free. All that is to say, if the upstream Emacs contribution/onboarding process seems less than ideal, cut it some slack. The project as a whole primarily runs on the blood, sweat, and tears of unpaid contributors. If you can, fund the maintainers you rely on (or better yet, get your employer to do so). If you've been thinking of contributing to Emacs upstream, don't procrastinate like me and just give it a try. Compared to the typical GitHub pull-request process, your first Emacs contribution may feel a little daunting and dated, but there's a lovely fuzzy light at the end of the tunnel. You see, Emacs has been around for 50 years . Very few software projects get to live this long. Landing contributions on a project with such a rich history is a real treat! But I digress… Let's get moving. Once I got over procrastinating, I finally got a handful of small contributions landed on the master branch. Thank you, Eli Zaretskii, Stefan Kangas, and Gerd Möllmann, for your help. From then on, I eagerly waited for them to formally make it to a stable release. Emacs 31 shipped the lot. I do enjoy a visual (and functional) tweak here and there , and a Dired tweak felt small enough to be the perfect candidate for my very first Emacs contribution. With that in mind, I tweaked by adding the user option, which hides the directory's absolute path, typically displayed at the top of Dired buffers ( bug#72272 , commit ). More on this in my Hide another detail post. At some point, I ran into a snag trying to run macosrec from my beloved . The process just crashed with a cryptic , so the issue wasn't super obvious. It turned out the utility required granting an OS permission that can only be requested by the host app (Emacs) if it includes the relevant description in its file. As of version 31, Emacs includes in its ( bug#72827 , commit ). now includes a "Send to…" item, enabling sending the current file(s) or region text to external apps or services. You can also invoke directly. On macOS, it's powered by the native sharing picker (I use it frequently to AirDrop things to my iPhone). Elsewhere, it falls back to ( bug#76120 , commit , follow-up fix ). These two implementations plug into new generic plumbing ( ), so you could, for instance, add a handler sharing via Android's native share sheet ( can do the heavy lifting) or KDE Connect on Linux ( ). More in my Emacs send-to (aka macOS sharing) merged upstream post. Emacs 30 lost macOS dictation when migrating to . Implementing in brought it back ( bug#79070 , commit ). With LLMs/agents being a thing these days, dictating into your Emacs buffer may be just the thing to complement your AI workflow. I covered this in my macOS dictation returns to Emacs (fix merged) post. Are you getting value from any of my upstreamed changes or my Emacs packages? Please consider sponsoring to keep the work going. While my patches may seem relatively straightforward, some took quite a bit of effort to land upstream . My Emacs work not your cup of tea? No worries. As mentioned earlier, sponsor the maintainers you rely on instead.

0 views

The Epistemic Jerk

In physics, jerk is the rate of change in acceleration. It’s the feeling in your body when a driver slowly accelerates before slamming on the gas. While thinking about AI, I keep returning to this word: jerk . It captures the feeling of suddenness and surprise at the staggering rate of change. Within roughly two years, many programmers have gone from writing code “by hand” to using AI to code nearly everything. And it isn’t slop anymore. Coding agents can convert mockups into websites, write bug patches for the Linux kernel, and reverse-engineer compiled binaries. Overnight, the experience of programming has changed. Many developers point to Anthropic’s release of Opus 4.5 as the moment agentic coding started to work. The model was released less than a year ago. Similarly, a few years ago LLMs would routinely fumble basic arithmetic. Then Google’s Deep Think achieved gold-level performance at the 2025 IMO. Then OpenAI said its internal model had produced a Lean proof resolving the Navier–Stokes Millennium Prize problem. Then OpenAI dumped over 700 papers on GitHub, with results ranging from the unique games conjecture to quantum magnets. The progress is so rapid that the math community is having a collective and public reckoning. For myself, this has been humbling. I started my PhD in machine learning in 2016, a year before the transformer. I’ve published a paper using deep learning to extract latent representations from histology slides. I’ve written about LLMs and hosted vibe-coding hackathons for friends. And I write code and solve technical problems every single day. I guess my point is this: I’ve had my eye on the puck for a while now, and I am still shocked at the rate of progress. What happens next? AI safety researchers warn about misalignment and existential risks. Tech workers worry about job losses and a shock to knowledge work. Accelerationists argue we should move even faster to maximize technological progress. And market bears say that AI capex debt is a house of cards that will eventually crash the economy. Meanwhile, most people’s view of AI is shaped by outdated chatbots. It’s a disorienting time. As I’ve tried to make sense of the moment, I keep circling the same inchoate thoughts. Here are some of them. We are all fitting superlinear functions to a handful of data points. In Bayesian inference, your posterior distribution can widen (more information doesn’t always make you more certain). In a world in which specialized skill becomes commoditized, people with problems to solve will thrive relative to people who want to be told what to do. It is an insidious failure mode to solve problems you don’t actually care about simply because AI has made them easier to solve. I struggle to tell the difference between cognitive surrender and a higher level of abstraction. I derive a lot of existential pleasure from deep understanding, and I don’t want to lose that. One kid is using AI to do their math homework, while another is using AI to teach themselves calculus. The transistor isn’t even a hundred years old. I have never made a value-aligned decision from a place of fear. Do not mistake the shock or uncertainty of this moment for fatalism or powerlessness. While my thoughts are incomplete, my conviction is not. I keep telling friends about this time I watched Hikaru Nakamura play bullet chess on his live stream. He was chatting casually to the audience while moving at lightning speed when he suddenly paused and burnt most of his remaining time deciding his next move. After he won, he talked about the importance of that move. I forget the details, but he had sensed a shift in the game, a pattern that felt off. He paused because the next move was critical. That is what this moment feels like to me. So this is a time capsule for myself, a record of this feeling. Genuinely, I don’t know what happens next, but I can feel in my shoulder blades that the game has changed.

0 views
Unsung 2 days ago

“And honestly, that feels like magic.”

This is a really fun video by 3Blue1Brown about the cleverness and elegance of Hamming codes, simple algorithms that help recover data when some of it gets mangled – for example, if you scratch your CD disc: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/and-honestly-that-feels-like-magic/yt1-play.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/and-honestly-that-feels-like-magic/yt1-play.1600w.avif" type="image/avif"> The default assumption for complete data protection might be to have a second, backup copy to be sure. But Hamming codes not only promise the same kind of safety in a fraction of the space needed – they also can point to where exactly the data was damaged, and in many cases they can even fix the damage, for free. And the code required is trivial, too . It reminded me quite a bit of this video about Unicode , another example of beautiful and smart encoding.

0 views
Jeff Geerling 2 days ago

Ops needs friction

Between Microsoft's two-day outage and the FAA ground stop yesterday , there's plenty of ink spilled about who's responsible, why these things happened, etc. But it made me think back to some of the infrastructure and ops teams I've worked on, and similar (though much smaller scale) outages we encountered. Having an ops mindset is fundamentally different from a development or project management mindset. And it took me over a decade of software development to understand why.

0 views
Robin Moffatt 2 days ago

Itches I Have Scratched (November 2026)

My background is databases, SQL, ETL, all that kind of thing. Not coding. Well, maybe a hack (and a dirty one) at best - BBC Basic in the old days, VBA in Excel a long time ago, and more recently even trying to learn Go . All enough to just about get by, none to seriously trouble anyone for whom this is actually their job. And I was quite content with continuing my next decades as I’d spent my previous ones, thinking of fun software, occasionally finding the time to hack at something trivial, but nothing more. And then agentic coding came along, and turned my world upside down :)

0 views

Building Kakuro Zone

I built Kakuro Zone ! When I go on work trips, I often use hotel business centers to print out some paper puzzles to do if I’m bored in the hotel room or on the airplane. I almost always do sudoku puzzles, but wanted to mix it up. As I started exploring different puzzles, I discovered kakuro ! They’re a type of logic puzzle very similar to a crossword puzzle, except you add numbers across and down to fulfill rows and columns. It’s super fun to do with paper and pencil! There’s quite a few kakuro puzzle websites out there, so I didn’t have to make a new website for them but: With the power of AI, I actually got pretty far a couple months ago! I set it up to be a React and Vite PWA, and got my printable puzzles all done in time for the WeAreDevelopers conference! I had printed puzzles for the week, and was able to play a bit on my phone on the plane as well. …and then I promptly ignored the repo until this week, because it solved my needs, ha. After the hubbub of GitHub Universe died down, I remembered that I should open source the game and clean it up so that others can play it too. This is, admittedly, a fairly vibe-coded project. Or should I say, agentically engineered . I did some touching of code, mostly in the CSS. I really cared about the what things should look like on different screen sizes, and how navigation should feel with a keyboard or on mobile, but besides that, I let GitHub Copilot fly here. It felt weird letting go… but it was also nice to just get the puzzle experience the way I wanted, without overthinking implementation logic. Here’s the repository , and here’s the game again for you to try out! I wanted to print them in a certain way that would fold well in my notebook I liked the idea of using the date as a “seed” for a puzzle, so I could have a friend do the same puzzle as I did on a given day I wanted to have the game on my phone if I didn’t print it out (but felt a hankering to solve one) I wanted to play with Neobrutalism.dev

0 views
Sean Goedecke 3 days ago

How to find meaning in large tech companies

Why do many people hate working in large tech companies? The obvious answer is “because organizational dysfunction stops them from doing the things they want to do”. Engineers like to write code and ship things, and if their company’s dysfunction is preventing that, it’ll make them unhappy. Right? I don’t think so, actually. If that were the case, those people would be interested in understanding the dysfunction and learning how to work around it, so they can do more of the things they want to do 1 . However, many people seem to actively avoid that. They find even contemplating the dysfunction to be as unpleasant as actually dealing with it. I think the reason for that is similar to why most people don’t like working in a messy room. People — particularly engineers — have a compulsion towards neatness. As I’ve written about before , it’s often our weird internal compulsions that drive our professional selves. If you feel a visceral disgust towards organizational dysfunction, spending any time thinking about it probably feels like being tainted. In Anathem , Neal Stephenson writes about a strange punishment where initiate scholars are forced to study “The Book”: a text written to be both complex and entirely meaningless. It takes a lot of intellectual effort to master The Book, but there’s absolutely zero useful content there. Studying it is thus a kind of self-damage. In Stephenson’s words, “the punishment lay in knowing that you were putting all that effort into letting a kind of intellectual poison infiltrate your brain”. Even if you’re not instinctively repulsed by inefficient organizations, working in one can take its toll. There are many, many things that a large tech company treats as important that are hard to take seriously: OKRs, some deadlines, internal training, attempts to build “hype” among employees, and so on. Acting emotionally invested in all of this can be alienating 2 . Getting good at persuading yourself to act like unimportant things are important is a lucrative but dangerous skill. If you do it long enough, it can feel like importance itself is an illusion. Before I became a software engineer, I did a master’s degree in philosophy 3 . When you tell people you’re studying philosophy, many people will ask if philosophy can solve their existential angst: they feel that the universe is very big and uncaring, and that humans make up only a tiny pin-prick of it, and that therefore nothing matters. Philosophers must have written about that, right? What’s the solution? The solution is to stop doing philosophy . If working in a dysfunctional organization has convinced you that nothing matters, you should refute that by coming into direct contact with things that matter. Go hang out with your kids, or take a walk in the park, or read a good book, or take your medication 4 . In other words, spend less time thinking about work 5 . I think this is good advice. But I also think there is quite a lot of real value and meaning you can get from working in a large tech company. Where is it? At large tech companies, millions of people will benefit from the work you do . If you make an amazing video conferencing app that a handful of people use, you will have to derive your satisfaction from the quality of your work. But if you can make Teams a tiny bit better, you’re making a tiny improvement in the lives of millions of people who use it. It isn’t easy to make enterprise pieces of software better, for lots of reasons . It sometimes requires jumping through awkward hoops or playing demeaning political games. However, it’s such a valuable thing to do. Every bug you fix or feature you add saves cumulative months or years of users’ time. This is still true if the software you’re working on is steadily getting worse, as most pieces of enterprise software do. Slowing that process down is important! Software engineering is really hard. Getting anything done in large organizations is also really hard. The intersection of these two hard problems is a nightmare morass of difficulty. It is not for the faint of heart 6 . Engineers from smaller organizations will mock you and invent fantasy stories about what your work is like. But if you can handle it — if you’re tolerant of mess, and if you have a rich enough personal life to be able to treat work politics with a healthy detachment — it is as rich a source of meaning as you could ask for. More or less the mission statement for this blog. I wrote about this in much more detail in Selling out . My specific subfield was “moral epistemology”: how we can know what’s right and wrong. If you think it’s a bit anachronistic for philosophers to believe in right or wrong at all, I suggest reading this Reddit post I wrote a long time ago: moral realism is surprisingly popular among academic philosophers. I mean this seriously. There are probably 1% of people who are so philosophy-brained that their existential angst does in fact derive from how seriously they take the arguments. These people might benefit from doing more philosophy. Everyone else is just depressed. At the risk of cultural stereotype, I think it is kind of distinctively American to try and derive your primary meaning in life from your workplace. On the other hand, you do spend a huge chunk of your life working, so it had better not be completely meaningless. I’m being hyperbolic here: in fact it is a relatively chill, well-paid job. More or less the mission statement for this blog. ↩ I wrote about this in much more detail in Selling out . ↩ My specific subfield was “moral epistemology”: how we can know what’s right and wrong. If you think it’s a bit anachronistic for philosophers to believe in right or wrong at all, I suggest reading this Reddit post I wrote a long time ago: moral realism is surprisingly popular among academic philosophers. ↩ I mean this seriously. There are probably 1% of people who are so philosophy-brained that their existential angst does in fact derive from how seriously they take the arguments. These people might benefit from doing more philosophy. Everyone else is just depressed. ↩ At the risk of cultural stereotype, I think it is kind of distinctively American to try and derive your primary meaning in life from your workplace. On the other hand, you do spend a huge chunk of your life working, so it had better not be completely meaningless. ↩ I’m being hyperbolic here: in fact it is a relatively chill, well-paid job. ↩

0 views
Kev Quirk 3 days ago

2026 Self-Host User Survey Results

by Ethan Sholly Visualized results across 6,200+ responses to 2026's annual user survey. Read post ➡ Fascinating look at how people (like me) self-host their tech stack across the Internet. There were some surprises for me, like Debian being above Ubuntu, and Android being far more popular that iOS. Interesting reading if you like data. Thanks for reading this post via RSS. RSS is ace, and so are you. ❤️ You can reply to this post by email , or leave a comment .

0 views

I moved 39 repos into a monorepo to boost agentic coding

Hey, what's up? It's Takuya here. I recently moved my projects into a monorepo to speed up my agentic coding. I came across a post by Mitchell Hashimoto . He recently started a new company, Superlogical, which builds Rex , a terminal app designed for working with AI agents. His team is small, and everyone on it is trusted to push commits straight to main. They skip the traditional flow of opening a pull request, waiting for someone to review and approve it, and then merging it. Instead, AI reviews the code before the push, and humans and AI review it again after it lands. Their workflow looks super fast. I'm a big fan of Mitchell, and I admire the quality of his work, like Ghostty. So I trust his technical decisions, including how his company uses AI. His post inspired me a lot and made me rethink my own workflow, starting from how my repositories are structured. Before I started coding with agents, each of my private modules lived in its own repository and was published to npm from there. Development was slower before AI, so I usually focused on one module at a time: make the changes, publish a new version, then update the apps. With semver, a change in one module couldn't unexpectedly break the apps. Many of these packages are shared across multiple projects, so this workflow was crucial for me. When I started using Claude Code, I kept the same structure, and at first it simply sped up my traditional workflow. But the more I relied on agents, the more friction I felt. AI makes a lot of changes, blazingly fast, so my workflow became the bottleneck. I had set up trusted publishing on npm, so GitHub Actions published new versions automatically. Still, after every change to a package, I had to wait for the publish run to finish before an app could use the new version. Agents also make many changes that span multiple modules, and keeping the module structure in shape became painful. Because each task was spread across several repositories, agents often missed shared constants, functions, and APIs. I think my job now is to help AI make fewer mistakes. One way to do that is to give the project a shape where AI can quickly understand the whole picture: where to look and where to add things. That's why I decided to move to a monorepo. The transition wasn't that simple. I have an Electron app, a React Native app, and a web app, each with its own tech stack and package manager (my server-side code stays in its own repos). Most packages used pnpm, but the React Native app used Yarn, so I had AI switch it to pnpm. Some of my repositories are public, as contributions to the open source community: for example, React Native modules and tools that help developers build Inkdrop plugins. Those can't move into a private monorepo. Everything else moved in, and the repository is now a single pnpm workspace. I used to bring each repository in with its full git history. For each repo, it moved every file into its new folder (for example, or ) across all past commits. It also renamed the tags to the format, like , since every repo had its own . And it rewrote bare issue references like in old commit messages to , so they still point to the right repository. Then I merged each rewritten repo into the monorepo with . For the plugin-related repositories, I made a second, public monorepo ( inkdropapp/plugins ). So now there are two monorepos, and the release flow looks like this: With everything in one repo, I could also unify the toolchain. Some modules still used ESLint and Prettier, so I migrated them all to Oxlint and Oxfmt, which now run once from the root. I also tried Vite+ , a unified toolchain that bundles Vite, Vitest, Oxlint and Oxfmt behind a single command. I was already using most of these tools in my modules, so switching looked easy, and its task caching promised a faster loop with agents. But in my case, its type-check cache reported a broken TypeScript 7 project as passing. With agents, that's risky: they see a green check and move on. There also wasn't much build time to save in the first place, so I decided not to go with it. I'll try it again in the future. This work took two days to finish, and I'm happy with the result. Now, my agent and I can quickly update modules and keep them aligned in a single change, and I can comfortably create a git worktree for each task. Before the move, a task that touched several repositories needed a worktree in each of them, and that was painful. So, this transition has already paid off. Inkdrop's codebase is over 10 years old. If you also have an old project split across many repositories, I hope this helps you rethink how you work with agents. I have so many ideas to improve my app, and I'm so excited to work on them starting next week. That's it! Thank you for reading.

0 views
Anton Zhiyanov 3 days ago

Probabilistic data structures in Go

Probabilistic data structures give you approximate answers to questions about the data they handle. Does the set contain a certain item? How many unique items are in the collection? Which items appear most often? Unlike deterministic structures like sets and frequency tables, the answers might not be exact, but in return, you can drastically reduce memory usage. In this post, we'll talk about what probabilistic structures are, how they work, and what kinds of guarantees they provide. I'll also introduce unsure — a package that implements these structures in Go. It's simple (the core logic for each data structure is 100–300 LOC), fast (usually several times faster than other implementations), and has no dependencies except for the standard library. Bloom filter • Count-min sketch • HyperLogLog • T-digest • Top-k A Bloom filter is a set that trades certainty for space. It can tell you that an item is definitely not in the set, or that it probably is (which might be a false positive). The filter doesn't actually store the items, so it's much more compact than a regular set. For example, a regular set with 1,000,000 distinct 8-byte strings takes about 64 MB. A Bloom filter for the same strings, with a 1% false positive rate, uses only 1.24 MB (about 10 bits per item) — that's 50 times smaller. The size of the filter doesn't depend on the item size, so the difference gets even bigger with longer strings. A Bloom filter often resides in memory and helps minimize expensive I/O operations such as disk reads or network calls. You check if an item is in the filter, and if the answer is "no", you skip the costly lookup. If the answer is "yes", you still have to perform the lookup because it might be a false positive. The filter is sized for the given number of items with a given false positive rate. You can add more, but the false positive rate will go up. You can add an item to a Bloom filter and check if an item is in the filter, but you cannot delete an item, count the number of items, or iterate over them. Bloom filter 1 is a large array of m bits, all set to zero at first. To add an item, you compute k hash values for it and set the k bits at those positions: To check if an item is in the filter, you compute the same k hashes and check if all k bits are set: The k bits are randomly distributed throughout the entire array. When the filter is larger than the CPU cache, each bit access could result in a cache miss, so a lookup may wait on memory k times. Unsure uses a blocked Bloom filter 2 . The bit array is divided into 512-bit blocks, each matching the size of a CPU cache line. When you add or check an item, it is hashed once: part of the hash selects a block, and the rest selects k bits within that block. Each add or check only accesses one cache line, so the filter stays fast even when it's very large. In a blocked Bloom filter, some blocks end up with more items than others, which increases the false positive rate. To make up for this, the filter needs to be a bit larger. Compared to a standard Bloom filter, it uses about 3% more memory at a 1% false positive rate, 8% more at 0.1%, and 15% more at 0.01%. The filter uses the local wyhash 3 implementation for hashing. It performs roughly the same as xxh3 4 but has a much simpler implementation, without SIMD or assembly. Here's an excerpt from the full benchmarks 5 , comparing unsure to bits-and-blooms 6 (a classic Bloom filter) and gloom 7 (a blocked one) (ns/op, lower is better): Memory, bits per item at 10M items (lower is better): Unsure is about 4× faster than bits-and-blooms and 2× faster than gloom , using 1–8% more memory than bits-and-blooms and 4–10% less than gloom . A count-min sketch is a frequency table that trades accuracy for space. It tells you approximately how many times each item has appeared. The estimate is never less than the actual count, but it can be higher . The sketch doesn't actually store the items, so it's much more compact than a regular map of per-item counts. For example, a regular map counting 1,000,000 distinct 8-byte strings takes about 64 MB. A count-min sketch for the same strings, with estimates within 0.01% of the total count (with 99% probability), uses only 0.55 MB — that's 116 times smaller. The size of the sketch doesn't depend on the number of distinct items or their size, only on the accuracy you choose. So the difference gets even bigger with more or longer strings. A count-min sketch is useful when you want to track how many times an item shows up in a large stream of events. It's often used to check if something has happened a certain number of times, like rate-limiting an IP after X requests or sending an alert after an error happens Y times. A sketch can also help decide if a key is worth keeping in the cache given how often it was requested. The sketch uses two settings: epsilon ε and delta δ . If the actual count for any given item is X and the total of all counts is N, then the estimated count for this item will usually be between X and X+ε·N. However, rarely (with a probability of δ) the estimate could be even higher. For example, if ε is 0.001, δ is 0.01, and N is 1 million, then the estimate could be off by up to 1,000 (ε·N) with at least 99% probability (1−δ), and by more than 1,000 with at most 1% probability (δ). The counting error in a sketch depends on the total of all counts, not on each individual item. Therefore, frequent items are estimated more or less accurately relative to their count, but rare items are not — the absolute error is too high for them. You can increase the per-item counter in a sketch and get the estimated count for an item, but you cannot decrease a counter or iterate over the items. Count-min sketch 8 is a table of counters with d rows and w columns, all starting at zero. Each row uses its own hash function that maps an item to one of the w counters. To add an item, you increment its counter in each row: To estimate an item's count, you take the smallest value from its d counters: With w = e/ε columns, each counter's error is at most ε·N, with probability at least 1 − 1/e. If you use d = ln(1/δ) rows, the chance that all d of the item's counters exceed its true count by more than ε·N is ≤ δ. Unsure uses a conservative update . When you add n to an item, it first finds the current estimate E (the smallest counter), then increases only the counters that are below E+n, leaving the larger ones unchanged. This keeps the same accuracy guarantee, but the actual error is about 2× lower. The tradeoff is that counts can't be decreased. Counters are 32-bit instead of the usual 64-bit, so the sketch uses 2× less memory. The item is hashed once, and each row gets its own position from that hash by salting it (multiplying by a random per-row constant). The sketch uses wyhash for hashing. Here's an excerpt from the full benchmarks 9 , comparing unsure to BoomFilters 10 (a classic count-min sketch with 64-bit counters) (ns/op, lower is better): Accuracy at ε=0.0001, N=10M additions over 1M distinct items, mean overestimate (lower is better): Unsure is about 1.5× faster for Add and 4× faster for Count, using 2× less memory with 2–2.7× lower error. HyperLogLog is a unique items counter that trades accuracy for space. It tells you approximately how many distinct items it has seen, no matter how many times each one appeared. HyperLogLog (also called a sketch from here on) doesn't actually store the items, so it's much more compact than a regular set. For example, a regular set of 1,000,000 distinct 8-byte strings takes about 64 MB. A HyperLogLog sketch counting the same strings with about 0.8% error uses only 16 KB — that's almost 4,000 times smaller. The size of the sketch doesn't depend on the number of items or their size, only on the accuracy you choose. A 16 KB sketch counts a billion items as accurately as a thousand. HyperLogLog is useful when you need to count unique things in a large stream: unique visitors to a website, unique search queries per day, or distinct values in a database column. You can merge sketches to gather data from multiple machines or segments (like by hour, page, or region). When you merge two sketches, you get the total number of unique items from both, without counting shared items twice. The sketch has one setting: the precision p , which gives a relative standard error (stdErr) of 1.04/√(2^p). A common default is p=14, which gives 0.81% error. With p=14 and 1 million distinct items: The error is relative to the count, so the standard error is the same 0.81% for a thousand items or a billion. You can add items to a sketch, get the estimated count, and merge sketches. You cannot check if a specific item was added, remove items, or list them. HyperLogLog 11 is based on a simple observation. If you hash items to random bit strings, about half of them start with 1, a quarter with 01, an eighth with 001, and so on. Seeing a hash with k leading zeros suggests there were about 2^(k+1) distinct items. Duplicates hash to the same value, so they don't affect the result. A single observation is unreliable, so the sketch divides the items into m = 2^p groups, where p is the selected precision. The first p bits of the hash pick a group (a register ), and the register keeps the highest rank (leading zeros plus one) it has seen in the rest of the hash: The count is estimated from all the registers together, using a harmonic mean of 2^register. The standard error is about 1.04/√m. Merging two sketches is just taking the maximum value from each pair of registers. The original estimator is biased when dealing with small counts (up to a few times m), so in these cases it uses a different formula called linear counting . This switch creates a sudden change in error, and some implementations (like HyperLogLog++ 12 ) address it by using large tables of bias corrections based on real data. Unsure uses the improved estimator by Otmar Ertl 13 . Instead of a harmonic mean of the registers, it works from a histogram : how many registers have value 0, value 1, and so on. A formula applied to the histogram gives an accurate estimate for any number of items, from zero to billions, so there's no need for a separate formula for small counts or for correction tables. The sketch updates the histogram whenever registers change. Most adds don't change any registers, so this is almost free. Counting always takes the same amount of time, no matter how big the sketch is. Other implementations scan all the registers on every count, which takes from microseconds to milliseconds. Registers are one byte each, and the histogram has 64 four-byte counters (256 bytes). The item is hashed once with wyhash , and the 64-bit hash is split into the register index and the rank. Here's an excerpt from the full benchmarks 14 , comparing unsure to axiom 15 (HyperLogLog with LogLog-Beta estimator and sparse mode) (ns/op, lower is better): Accuracy at p=14 (0.81% standard error), relative RMSE over 100 sketches (lower is better): Memory at p=14 after adding the given number of distinct items (lower is better): Unsure adds about as fast as axiom , counts 270–83,000× faster, and merges 2.3–2.9× faster, with the same accuracy and memory for counts above the number of registers. When there are fewer items than registers, axiom 's sparse mode makes it more accurate and compact. A t-digest is a summary of a stream of numbers that trades accuracy for space. It can give you an approximate median, 99th percentile, or any other quantile of the data. It can also estimate what fraction of the numbers are below a certain value (the CDF). The digest doesn't actually store the numbers, so it's much more compact than a sorted list. For example, to find the exact 99th percentile of 1,000,000 numbers, you'd have to keep all of them. With 64-bit floats, that takes 8 MB. A t-digest estimates the same percentile within about 0.03% of the rank (between the 98.97th and the 99.03rd percentile) using only 8 KB — 1,000 times smaller. The size of the digest doesn't depend on the number of values, only on the accuracy you choose. An 8 KB digest summarizes a billion values as well as a million. A t-digest is useful when you need quantiles over a large stream: latency percentiles for a service, the distribution of request sizes or prices, or the outlier thresholds in sensor data. You can merge digests to gather data from multiple machines or segments (like by hour, endpoint, or region). A merged digest estimates the percentiles of all values, but with less accuracy than individual digests do. The digest has one setting: the compression δ , which limits the number of centroids (see How it works below) to δ+2. A common default is δ=100, which takes 8 KB. Increasing δ uses more memory but reduces estimation error. The error is measured in ranks: a rank error of 0.03% at quantile q=0.99 means the value returned by is somewhere between the 98.97th and the 99.03rd percentile of the actual values. Tail estimates, such as q=0.99 or q=0.999, are more accurate than the median (q=0.5). You can add numbers to a digest, estimate quantiles and the CDF, and merge digests. You cannot remove numbers or list them. T-digest 16 summarizes the numbers as a sorted list of centroids . Each centroid has a mean and a weight — the number of values it represents. To estimate a quantile, the digest finds the centroids around the requested rank and interpolates between their means. The trick is in how big the centroids are allowed to grow. A scale function k(q) maps a quantile q to a number from -δ/4 to δ/4, and each centroid may only span 1 unit of k: if a centroid covers the quantiles from q₁ to q₂, then k(q₂) − k(q₁) ≤ 1. The arcsine scale function, k(q) = δ/(2π)·asin(2q-1), is steep near q=0 and q=1 and flat near the median. This means the centroids it produces are larger in the center and smaller at the ends: With 1M values and δ=100, the centroids around the median hold about 27,000 values each, those around the 99th percentile about 5,000, and the outermost ones about 500. This keeps the error near the tails small. Unsure is the merging t-digest from the Dunning and Ertl paper. New values go to a buffer of 5·δ numbers. When the buffer is full, the digest sorts it and merges it with the centroids (already sorted) in a single pass, building new centroids from left to right as long as each one fits within its span of k. Every other pass goes right to left, so that neither tail ends up with fuller centroids. , and flush the buffer first. The centroids are kept in two fixed arrays of δ+2 entries (the current list and the next one being built), along with the cumulative weights for a binary search in and . With δ=100, that's 16·102·2 + 8·103 bytes for the centroids, and 8·500 bytes for the buffer, about 8 KB in total. Centroids with weight 1 are treated as exact values rather than spread around their mean, and the exact minimum and maximum are used at the ends. So digests with few values give exact results, and and are always exact. Here's an excerpt from the full benchmarks 17 , comparing unsure to influxdata 18 (merging t-digest with the same scale function) (ns/op, lower is better): Accuracy at δ=100, mean rank error over 1M normal values (lower is better): Memory at δ=100 (lower is better): unsure 8.5 KB, influxdata 14.4 KB. Unsure adds values about 1.8× faster than influxdata , queries at the same speed, merges 7–9× faster, and uses 40% less memory at about the same accuracy. A Top-k sketch finds the k most frequent items in a stream (the "heavy hitters"), along with their approximate counts. It uses a fixed amount of memory based only on k, no matter how many different items are in the stream. To find the exact top items, you'd have to count every unique item, for example with a map of per-item counts. With millions of distinct items, that takes tens or hundreds of megabytes. A Top-k sketch for the top 1000 items takes about 360 KB, and it usually finds all of them. A Top-k sketch is useful when you want to identify the "hottest" data: the most requested URLs, the most active users, or the most common search queries. Unlike a count-min sketch, it keeps the actual items, so it can list them. returns up to k items, from the most frequent to the least frequent. Counts are estimates: they're usually exact for the most frequent items, but may be slightly lower than the actual count for less common items. The sketch works best when the stream is skewed, meaning a few items appear much more often than the others. This is common in real situations. If all items are about equally frequent, there is no clear top k, and the results become less accurate. You can add items to the sketch and get the top items with their counts, but you can't decrease counts or check items that aren't in the top k. HeavyKeeper 19 is a table of buckets that estimates item counts. It has d rows and w columns, and each item maps to one bucket in each row. Each bucket holds a fingerprint of the item and a count. To add an item, you update its bucket in each row: The item's estimated count is the largest count among its buckets. Frequent items quickly reach counts that make decay very unlikely, so they keep their buckets. Rare items keep replacing each other without affecting the frequent ones. An item that becomes frequent later in the stream can still outnumber a less frequent owner and take over its bucket. Next to the table, the sketch keeps a min-heap with the k items that have the largest estimates so far. After an item's buckets are updated, if its estimate is larger than the smallest count in the heap, the item is added to the heap, and the smallest item is removed. If the item is already in the heap, its count is increased. Unsure uses d = 2 rows of max(16k, 256) buckets, and a decay base of b = 0.8. The probabilities b^count are precomputed as 64-bit thresholds, so decay is cheap: the count c decreases if a random number is below the c-th threshold. The original HeavyKeeper uses b = 1.08⁻¹ ≈ 0.93, and more rows. A smaller b lets frequent items lock their buckets faster, which makes the sketch more precise on flat streams. However, if b is too small (like 0.5), the first items to claim buckets keep them permanently, so items that become frequent later are never counted, even if they end up being the most frequent. Using b = 0.8 keeps most of the precision and still catches most late-arriving frequent items. As for the rows, two are enough to protect frequent items from collisions in a single row, and adding more rows only makes the sketch slower. The item is hashed once. The hash is mapped to a position in each row by salting it (multiplying by a random per-row constant). The fingerprint is the top 32 bits of the hash. The heap uses the 64-bit hash to identify items, so it doesn't compare the actual item bytes. Each bucket is 8 bytes (a 32-bit fingerprint and a 32-bit count), so the table takes 256·k bytes. The heap takes about 100 bytes per item plus the item itself. The sketch uses wyhash for hashing and wyrand for random numbers. Here's an excerpt from the full benchmarks 20 , comparing unsure to keiler 21 (HeavyKeeper with b = 0.9 and d = ln k) and dgryski 22 (Filtered Space-Saving 23 ) on the Zipf s=0.8 stream (time/op, lower is better): Precision is the fraction of the reported top k that is in the true top k (higher is better): Count error is the mean of |estimate − true| / true over the reported items (lower is better): Unsure is 2–4× faster than the others for Add and 1.8–4× faster for Top. On flat streams (s=0.6), it finds the true top k with 90–97% precision, while keiler drops to 38–70% precision with a count error of 62–94%, and dgryski to 19–52% with counts 18× or more too high. On skewed streams (s=1.0), all three are about equally accurate. As engineers, we usually want exact answers from our data. But sometimes, allowing a bit of uncertainty can cut memory usage by tens, hundreds, or even thousands of times. That's where probabilistic data structures come in: To use them in Go, try the nalgeon/unsure package: Space/time trade-offs in hash coding with allowable errors by Burton H. Bloom, 1970.  ↩︎ Cache-, hash-, and space-efficient Bloom filters by Felix Putze et al., 2009.  ↩︎ Reference wyhash implementation by Wang Yi.  ↩︎ Reference xxHash implementation by Yann Collet.  ↩︎ Bloom filter benchmarks .  ↩︎ bits-and-blooms/bloom by Daniel Lemire.  ↩︎ jcalabro/gloom by Jim Calabro.  ↩︎ An improved data stream summary: the count-min sketch and its applications by Graham Cormode and S. Muthukrishnan, 2005.  ↩︎ Count-min sketch benchmarks .  ↩︎ tylertreat/BoomFilters by Tyler Treat.  ↩︎ HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm by Philippe Flajolet et al., 2007.  ↩︎ HyperLogLog in practice by Stefan Heuleet et al., 2013.  ↩︎ New cardinality estimation algorithms for HyperLogLog sketches by Otmar Ertl, 2017.  ↩︎ HyperLogLog benchmarks .  ↩︎ axiomhq/hyperloglog by Axiom.  ↩︎ Computing extremely accurate quantiles using t-digests by Ted Dunning and Otmar Ertl, 2019.  ↩︎ T-digest benchmarks .  ↩︎ influxdata/tdigest by InfluxData.  ↩︎ HeavyKeeper: An Accurate Algorithm for Finding Top-k Elephant Flows by Junzhi Gong et al., 2018.  ↩︎ Top-k benchmarks .  ↩︎ keilerkonzept/topk by KEILERKONZEPT.  ↩︎ dgryski/go-topk by Damian Gryski.  ↩︎ Efficient Computation of Frequent and Top-k Elements in Data Streams by Ahmed Metwally et al., 2005.  ↩︎ If any of the bits is not set, the item definitely was never added. If all the bits are set, the item was probably added, but it's not guaranteed (the bits could have been set by other items). Other items might hash to the same counter, so each counter value is ≥ true count. The smallest counter is the one with the fewest collisions, so it's the best estimate. 68% of the time the estimate is within 0.81% (8,100) of the true count, 95% within 1.6% (2·stdErr), 99.7% within 2.4% (3·stdErr). If the bucket is empty or owned by the item, increase its count. If the bucket is owned by another item, decay it: decrease its count by 1 with probability b^count (b < 1). When the count reaches 0, the new item takes over the bucket with a count of 1. Bloom filter checks if an item might be in a set. Count-min sketch estimates how many times each item has occurred. HyperLogLog estimates the number of distinct items. T-digest estimates quantiles of a stream of numbers. Top-k sketch identifies the most frequent items in a stream. Space/time trade-offs in hash coding with allowable errors by Burton H. Bloom, 1970.  ↩︎ Cache-, hash-, and space-efficient Bloom filters by Felix Putze et al., 2009.  ↩︎ Reference wyhash implementation by Wang Yi.  ↩︎ Reference xxHash implementation by Yann Collet.  ↩︎ Bloom filter benchmarks .  ↩︎ bits-and-blooms/bloom by Daniel Lemire.  ↩︎ jcalabro/gloom by Jim Calabro.  ↩︎ An improved data stream summary: the count-min sketch and its applications by Graham Cormode and S. Muthukrishnan, 2005.  ↩︎ Count-min sketch benchmarks .  ↩︎ tylertreat/BoomFilters by Tyler Treat.  ↩︎ HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm by Philippe Flajolet et al., 2007.  ↩︎ HyperLogLog in practice by Stefan Heuleet et al., 2013.  ↩︎ New cardinality estimation algorithms for HyperLogLog sketches by Otmar Ertl, 2017.  ↩︎ HyperLogLog benchmarks .  ↩︎ axiomhq/hyperloglog by Axiom.  ↩︎ Computing extremely accurate quantiles using t-digests by Ted Dunning and Otmar Ertl, 2019.  ↩︎ T-digest benchmarks .  ↩︎ influxdata/tdigest by InfluxData.  ↩︎ HeavyKeeper: An Accurate Algorithm for Finding Top-k Elephant Flows by Junzhi Gong et al., 2018.  ↩︎ Top-k benchmarks .  ↩︎ keilerkonzept/topk by KEILERKONZEPT.  ↩︎ dgryski/go-topk by Damian Gryski.  ↩︎ Efficient Computation of Frequent and Top-k Elements in Data Streams by Ahmed Metwally et al., 2005.  ↩︎

0 views
matduggan.com 3 days ago

So all software is free as in money now?

A few weeks ago I was up late in my kitchen. I've always been a bad sleeper, starting from when I was 10 and would spend whole nights reading books and watching the clock slowly wind it way to when I had to get up and go to school. Like most things, I hoped it would go away when I was older and instead has now become something I've just gotten used to. My friends all know this about me, so I'm typically who you call if you also can't sleep or have a sick baby and want to speak to another adult. It's whatever the opposite of a superpower is. It was during this period I got a text message from a friend with the line "someone has made the Adobe Suite with AI and it's free". Without any additional thought I proclaimed to my empty kitchen with its too-small European refrigerator "that's the stupidest fucking thing I've ever heard". There is frankly nothing worse than the endless cycle in tech of "we've cracked a hard problem in an easy low effort way". Every single time there is always a giant asterisks, something it doesn't do, something where the illusion falls away. Obviously I hadn't yet actually tried the software before I uttered this confident proclamation to my picture of a corgi as a dictator that I keep hanging on my kitchen wall. There was no way you could recreate what Adobe had made, right? When I graduated from college in 2008 and I watched in horror as my friends all moved back in with their parents, I decided I'd rather freeze to death in Chicago than suffer that fate. So I got a job that my childhood spent in local PC repair stores and college IT department helpdesks didn't really prepare me for by basically acting confidently. I was a corporate Mac IT contractor who wandered from skyscraper to skyscraper with my Manhattan Portage Messenger bag that had cost way too much money and hurt my shoulder with all the tools and spare 3.5 in hard drives I had to carry. The primary market for Macs at that time was college students and creative departments. Frankly, nobody else wanted them or had the budget for them. Creative departments inside of large corporations are a strange place to work. Often I would get escorted by security past rows and rows of cubicles (god remember when we thought cubicles were dehumanizing? We hadn't seen the unending horror of the open office plan yet). The creative department was usually the only place where even an attempt had been made to make the place less depressing. They often had like real books on shelves, art on the walls and the only employees in the entire place you would describe as "fashionable". The spaces were dominated by giant printers that would produce the full-size examples of "wraps" for buses or other large-scale advertisements. There were often a bank of color-calibrated monitors with hoods on them in a special area, which was always a thankless job. Color calibration was me attempting to prove with my little device that we were exactly on target with the Pantone colors on these specific monitors while the creative director would wander by, dressed like a college professor and confidently explain to me that "it's closer to Classic Green not Poison Green". They'd go get the Pantone color cards out of their office. From my perspective it seemed like a lot of people arguing a lot over whether to move rectangles in InDesign. There was no question that the tools they were using were Adobe tools. Nobody ever even asked if they really needed Adobe, in the same way that nobody ever asks "is water pressure actually important". The most reliable work I got was from a design studio in River North run by a woman named Donna. Donna was a life-long Chicagoan who seemed to liked me as an employee exclusively based on my willingness to walk and talk with her as she endlessly patrolled the upper level walkway. The pit area were all the designers and the upper ring was the senior staff. They did a lot of print advertisements and campaigns, which meant fonts. Fonts, for those unaware, need to be licensed to be used. Default fonts, at least for Donna, were basically trash not to be trusted as even placeholders. She was the keeper of the font licenses and the font license software, ensuring everything was paid for and allocated correctly. She liked to issue threats and then pretend they were a joke. "If a campaign ships with an unlicensed font, it'll be your ass! Anyway have a great day." She used to smoke in the alleyway behind the building in her pantsuits and a folded Wall Street Journal. I spent almost the rest of my time that wasn't spent on fonts troubleshooting problems with Adobe software. Teams would get legitimately nervous before updates to their core applications. Any changes to a shortcut would be met with a chorus of boos from the pit. The workflow was mostly ensuring that the local network share was up, backed up and performant. A lot of my day was ensuring the tape backups were working, shipping one set of backups to Iron Mountain for offsite storage which sounds cooler than it was. I was invited out to the temple of Adobe out in San Jose to chat with the folks there once. I don't remember the exact chain of events, but it was basically a large Adobe customer who wanted to ensure that they got some face time and I tagged along. I was horrified when you walked up to the building because at the time (around 2011) it basically looked like a bank. The lobby smelled like sorta old fabric and the offices were surprisingly run-down. Like as it turns out the nerve center for Photoshop was not quite as lux as that price tag would lead you to believe. It also didn't help that I never know how to dress for California weather. It's always colder than you think it would be? So after I tried and failed to find their parking garage, I ended up finding cheap(ish) parking like 5 blocks away and showed up to their office sweaty and flustered. But after spending the day with the folks there it was hard not to walk away with the impression that they cared deeply and truly about the sorts of creative problems their customers were trying to solve. They looked like the designers I was working with back in Chicago, with the same earrings and cool rolled up shirts. The demo stuff they were showing, I didn't really care about the software but I did care a lot about "is there maybe a way to shim a cheaper alternative to Adobe in there?" In short the people I met were very impressive and the answer was no. They had answers to every question I could imagine and every question my users had come up with. The software looked amazing and had just endless seas of options nested under options. I walked away with the complete confidence that regardless of what happened, unless they made a series of just catastrophic mistakes, they were entrenched forever in the creative space. Then they made a bunch of catastrophic mistakes. Originally creative software worked like....buying anything else expensive. It was a shrink-wrapped box that cost like an eye-watering amount, I think I remember $649 for Photoshop at some point. Then that turned into the Suite where it made sense to buy a license for the suite. This was kind of Adobe at the height of their powers, where it was cheaper to buy the whole rather than get the two parts you needed so then their file formats and patterns became just the default. Everyone needed one part of the suite so it was hard to kinda wedge yourself in there. If an upstart showed up they were typically acquired and then rolled into the Suite. Then Adobe watered down the value argument. I was still like vaguely involved with the entire ecosystem when the switch happened to Creative Cloud. It's kind of hard to...overstate how angry this made people. I don't think anyone has truly really measured the pure fucking fury that Adobe generated with this move. The combination of "there is no such thing as a perpetual license", the aggressive dark patterns for signup and the cancellation fees fundamentally changed the relationship Adobe had with its customers. Basically when Adobe retired perpetual license like a jersey, the vibes changed and the party was over. The best way I can describe it: some companies rely on the perception by their user that they have their best interest at heart. Apple is sorta like this. Adobe, I'd argue, was like this. The Microsoft Office team is maybe a bit like this as well. If Amazon screws you over well that's just them being their natural selves. Some greed is tolerated because they're cool and its understood to be a premium product. But if you cross sort of an invisible line of greed, the product is ruined in the minds of the consumers. For a lot of people, the butterfly keyboard Mac with no ports that broke a lot destroyed the entire concept of the Mac laptop for them. It was a shitty product that didn't work well that Apple didn't care enough to fix. There wasn't really a "coming back" for those users, because the illusion was shattered. Apple wasn't a cool group of creative California people they were assholes who were telling them to pound sand. Part of the mystique was killed and then you are left with a broken laptop and a trip to a dying strip mall. Microsoft Office was never the cheapest way to do a spreadsheet, word processing or slides, but it was pretty cheap and the file formats became the defacto standard. Then suddenly everyone collectively decided to cross the greed line at the same time. So I downloaded LightCraft as the primary Adobe software I use now is Lightroom. I've paid a subscription for...many moons for it. It works quite well, does exactly what I need. I had downloaded it expecting to hate it. Most LLM stuff looks nice and runs like shit, ending up being a giant waste of time. I also eye-rolled at "rewritten in Rust" which has become this new slang for "I didn't write any of it myself". At this rate nobody on earth will have ever hand-written Rust. The first sign something was good was how quickly it started. Adobe stuff opens slow, I assume to ensure that my paperwork is in order back at HQ. It also sipped RAM and CPU. As I went through my "workflow" which is a fancy way of saying "I take phone photos that suck very much and then try to make them slightly better", I was really impressed. The things weren't all in the same place, but more or less it worked as I expected it to. To be clear, I'm not suggesting these things are bulletproof. For instance, the Artcraft launcher is constantly telling me the launcher has an update. I'll hit update and it'll throw an error message. I'll quit the app and then it....seems to have applied the update? I also spent a few hours with DesignCraft which is their Adobe InDesign alternative and like we're still pretty far from that replacing InDesign as of right now. Great if you have some straight-forward needs for InDesign, but I think the Adobe moat is pretty strong there. InDesign people live or die by impossibly hard to detect errors. All that said, I was surprised how close a lot of the features got . Especially considering this is an LLM written clean-room implementation. Now to be clear I'm not a lawyer and that explanation makes no sense to me. I don't know why a "clean-room rewrite by an LLM" would be better than you making a Lightroom knockoff by hand. Feels like the clean-room part is making this sound a lot more scientific than it is. But as I spent hours clicking around and trying things out, I started to get a pit in my stomach. The best and worst thing about tech is that everything is constantly changing all the time. We've now gone from the moat being the price, distribution and shelf space to file formats, enterprise sales team to now the last remaining trickle of water being muscle memory and intellectual property. I was reading the interview in Ars with the folks behind this and the quote that popped out to me was "I one-shotted Photoshop. The whole thing". https://arstechnica.com/ai/2026/10/software-is-over-bold-ai-developer-takes-aim-at-adobe-with-open-source-clones/ That is a crazy sentence. If you aren't a developer, let me put it like this. Imagine if you read about the construction of Notre-Dame de Paris. Generations of workers, precise and hard to learn techniques, the whole thing. Some design elements we still don't fully understand today how they work. Then someone in Texas made a giant 3D printer that shot out a one to one copy in six months. Also there's a gift shop. I increasingly think the way we think about moats and barriers in software was always wrong. I think the actual moat was the goodwill built up over decades, the trust that these were professional tools and the people behind them wanted the best for you. Plus the 15+ years of muscle memory and just comfort in this ecosystem. You can 3D print software but you cannot really clean-room generate trust. But right now you don't need to, because every incumbent keeps giving their trust away, one dark pattern at a time. So what does this mean for software, if Adobe and Microsoft cannot keep the moat going? What if CADCraft does get good enough to threaten AutoCAD, a product with muscle memory older than some nations? Are we ever going to sell desktop software again, or is the future just an endless series of clones, produced by LLMs, with what specific features you want? I don't know. Meanwhile, the launcher has told me there's another update to the LLM Lightroom somehow. Right now the race feels weirdly inevitably, like watching a horse beat a car once and knowing in your heart that the car is gonna win in the end.

0 views
Unsung 3 days ago

“In the face of ambiguity, refuse the temptation to guess.”

Guido van Rossum shared a remembrance of Tim Peters , an important member of the Python community, who passed away earlier this year. I do not use Python all that much, and I wasn’t familiar with Peters’s work, but among his accomplishments was the Zen of Python , which consisted of 19 principles: (The links come from Wikipedia’s version . I kept them because they provide nice context for non-programmers.) I have always been wary of design principles. Most fall pretty to the classic saying “Everything simple is false. Everything complex is unusable.” I find the vague ones uninspiring, and the specific ones too rigid to be useful – a lot of design sooner or later arrives at “it depends,” and that’s hard to capture in a pithy one-liner. But there is something about (some of) these above that feels different, and Wikipedia entry suggests people actually found them useful . Perhaps they’re more pragmatic than usual, many expressed as “X over Y,” rather than fluffy stuff like “Move fast and break things” (evil), “Make it as simple as possible, but not simpler” (easy to abuse), or “Design is not how it looks, it’s how it works” (a perversion of Jobs’s “Design is not just what it looks like and feels like. Design is how it works.”) Or maybe they’re as bad and I see them as interesting only because they’re exotic, coming from the coding realm rather than the design one? Either way, they made me think what my own design principles would be. I arrived at a few of the first kind… …but I have to think about this all more carefully. Maybe more importantly, I’m interested in principles of those principles . Should each principle have a solid example showing you exactly how it’s been helpful before? You can sense there’s a real war story behind “Now is better than never. Although never is often better than right now.” and it would be great to read it. This is a thread in progress and I will report back. In the meantime, maybe Peters’s list would be useful for you to think about your list, too? Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested . Sparse is better than dense. Readability counts. Special cases aren’t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity , refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you’re Dutch. Now is better than never. Although never is often better than right now. If the implementation is hard to explain , it’s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea – let’s do more of those! 1fps or 60fps, but nothing in between. True UX delight is fiber, not sugar . Design assuming your every user will become a power user. You can ignore motor memory, but motor memory will never ignore you.

0 views
Robin Moffatt 3 days ago

Is it OK to write blog posts with AI yet?

Is it ever OK to write blog posts with AI? NO! was my strident cry until just a week or two ago (it was, actually, a much less polite version of that). Now, I’m wondering if I need to refine that view. Let me explain. You see, I have a particularly vitriolic feeling when presented with LLM-generated text. Articles written with AI give me the ick, I don’t trust them, and I lose respect for the author. I’m not the only one who feels this way; consider this finding from a survey by Cynthia Dunlop :

0 views