Latest Posts (20 found)

You don't have to be smart if you can think clearly

When you’re on fire, problems are transparent: they’re solved simply by the act of looking at them. Even complicated layers of multiple problems can simply be glanced through like stacked panes of glass. But nobody can work that way all the time. This is a common pitfall for smart engineers. Accustomed to being able to immediately intuit the solution, the first time they run into a problem they can’t do this to is a disaster. It doesn’t even have to be a hard problem, just a problem where for whatever reason they don’t see the trick right away. The difference between a “smart” engineer and a “strong” engineer is how they react to problems that aren’t solved instantly. A smart engineer might flail and struggle, hoping to find that flash of insight that eluded them; a strong engineer will have some process for methodically plodding away. There’s nothing worse than working with a smart engineer on their first really hard problem. When you don’t have the muscle to grind, it’s too tempting to just take any possible solution as the right one. Smart engineers can get into an increasingly-flustered loop of pointing to a series of bad solutions. They’re liable to panic: after all, much of their professional identity is bound up in their ability to solve problems easily. What skill do these smart engineers lack? I think it’s the ability to think slowly and clearly . Smart engineers can think clearly, but they can only think clearly at high speed. Strong engineers can think clearly all the time , even if their highest speed isn’t quite as fast. It’s like the difference between a Formula 1 car and a regular car: Formula 1 cars have a high top speed, but you couldn’t drive them in traffic, because the tyres and brakes don’t work at normal driving speeds. When I wrote about this before in Thinking clearly about software , I said that the key is to focus on the invariants : beliefs about the system that you know are true. When you’re stuck in a puzzling situation, it’s usually because some assumption you’ve made is false. If you’re able to identify the assumptions that can’t be false (for instance, if you’re getting an error message from the service, the service must be handling the request), that gives you solid ground that you can stand on to evaluate the assumptions that are less reliable. Thinking fast is about packing as much data in your brain as possible and letting your intuition leap to the right conclusion (or at worst, to a series of wrong conclusions that you can immediately dismiss before you come across the right one). It can feel deeply satisfying to make leaps like this; conversely, sitting with the raw data and not making mental leaps feels unsatisfying. People hate doing that. If you can force yourself to do something people hate, there’s typically a lot of value waiting to be extracted. This is no different. Engineers who can think clearly in a state of uncertainty tend to be extremely effective, whether they’re capable of great intuitive leaps or not.

0 views
Unsung Yesterday

“Rather than fighting my tendency to type these two characters in my omnibar, I neutralized it.”

An interesting short story from Ernie Smith at Tedium, who ventured out to do the opposite of what we usually cover on this blog – disrespect his motor memory : Recently, I made a realization: I have been unwillingly addicted to Facebook for a long time, and it’s not even because I like Facebook. Rather, it’s because I find it an extremely easy URL to type into a modern web browser’s omnibar. This sounds crazy, but the first two letters, f and a, are on the home row, and I don’t really rely on bookmarks, but my browser’s history function to type in URLs. This creates a sort of recency bias. If I type in the same URL a lot, it’s the one that pops up the most. And so, if I’m at a browser with no clear idea of what my intent for the next page I load up, I inevitably type in “fa,” which would suck me in. […] So, what I ended up doing was creating a URL that does nothing but forward to Google News. […] The result is that whenever I type in my new Facebook URL, I go to a news aggregator, which is inevitably what I was using Facebook for anyway. A week later, and my Facebook usage has gone down considerably. There is something really interesting about creating your own URL. Smith doesn’t disclose his, but you can imagine it’s something like that just redirects to a news aggregator. If creating a new URL is too difficult, there are always other options: Wanna go to fatberg.com every time you load your computer? Or maybe faxtoy.net ? This is a good example of some of the challenges with “recent” interfaces I am such a big fan of . If you’re designing recents and you think they can turn against the user or otherwise get in their way, it’s good to offer not just a “clear recents” feature that gets rid of them all, like here in Apple’s Music… = 3x)" srcset="https://unsung.aresluna.org/_media/rather-than-fighting-my-tendency-to-type-these-two-characters-in-my-omnibar-i-neutralized-it/1-framed.1600w.avif" type="image/avif"> …but also individual clears, like here in Bluesky: = 3x)" srcset="https://unsung.aresluna.org/_media/rather-than-fighting-my-tendency-to-type-these-two-characters-in-my-omnibar-i-neutralized-it/2-framed.1600w.avif" type="image/avif"> I don’t know if this is true for all the browsers, but in Chrome and Safari, you can also clear individual suggestions this way: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/rather-than-fighting-my-tendency-to-type-these-two-characters-in-my-omnibar-i-neutralized-it/3.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/rather-than-fighting-my-tendency-to-type-these-two-characters-in-my-omnibar-i-neutralized-it/3.1600w.avif" type="image/avif"> Smith writes a bit more about the addictive nature of computers, but I’ll let you read on your own . #attention #keyboard

0 views
Martin Fowler Yesterday

The Orchestrator's Tax

Subagents get justified by time saved and parallel execution, but Rahul Garg explains that's not what matters most. Every token in the orchestrator's context is competing for its attention, and the real value of a subagent is what it keeps out of that context. Subagents should be treated as a tool for protecting the orchestrator's working memory, offloading reasoning it doesn't need to hold onto. Doing this well means giving the orchestrator explicit ground rules for when and how to delegate.

0 views
Martin Fowler Yesterday

Why I’m Writing Rachel’s Ramblings

TL;DR I have ideas. I haven’t been writing them. That’s about to change. I promise… myself. I’ve been thinking a lot about talent. Actually, I’ve been thinking a lot about thinking. And writing. Or more specifically, not writing. This really hit me earlier this year at the Future of Software conference. I was surrounded by people sharing their latest ideas and I had a slightly uncomfortable realization: I have my own. Not just opinions. Actual patterns. Hypotheses. Things I’m seeing across clients, across teams, across the industry that feel new or at least not well articulated yet in a way that a leader can think about and act upon in some way that can influence how they strategise and plan for the future. Because helping clients and other leaders internal and external to thoughtworks do this is actually a big part of what I do and without letting my northern humbleness get in my own way, I’m actually pretty good at it. If I wasn’t I wouldn’t be the global CTO of a future thinking tech org, you know the kind that has Martin Fowler as its Chief Scientist. A title I know he loves… Martin, by the way, is one of the people pushing me to do this, which is weird because on paper I’m his boss but I don’t believe in the traditional idea of a boss anyway. I’m a strong believer in the servant leadership type but I’ll save that for when I write about that. Anyway the point is for all the ideas I have and discussion I have I don’t do a good job of writing it down. At best I’ll stick it in a presentation deck when I’m forced to communicate with them in some forum or another. I hate decks and love writing so I’m obviously doing something wrong. So why haven’t I been writing? It’s easy to say I’ve been too busy. I don’t have an easy job. It’s a fun one but not easy. I also have two small children, 5 and 8. In case you are interested, I attempt to give as much time as possible to this busy job. And then I try to have a life. I’m also writing an epic world building sci-fi fantasy book which is a huge passion project I may also share more about so I am definitely busy. But that’s not actually the real reason I haven’t been writing this down and pushing it out publicly. The real reasons… So this is an experiment. Rachel’s Ramblings is exactly what it sounds like. Fast, imperfect, thinking out loud. Naming ideas early rather than waiting until they’re fully formed. Because the reality is, most of what I do day to day isn’t answering known questions. It’s spotting patterns and asking questions we haven’t quite figured out yet. My brain works a bit like a knowledge graph. Constant associations, constant pattern matching. That’s useful in conversations, in client work, in strategy. It’s less useful if it never gets written down. So this is me fixing that. I’ll write about: Some of it will be wrong. Some of it will evolve. That’s the point. If nothing else, this is a forcing function to turn thinking into something that exists outside my head. Let’s see where it goes. I overthink it. I move too fast to the next idea. I’ve convinced myself it needs to be more polished than it does. what is the future of software how software development is changing in the age of AI and what that means for engineers, leaders, and organizations how platforms, agents, and people actually work together and occasionally, how I manage the reality of doing this job with all the other things I have going on

0 views
<antirez> Yesterday

The real AI risk is inside the labs

Amodei in his latest blog post wrote a mix of agreeable things and things that I believe misrepresent where the real risk of AI is located. I want to focus my attention on why, among all the risks, open weight models constitute the mildest one. I write these words as a person who strongly believes AI may be very dangerous in the near future: 1. Exactly like what happened during the OpenAI / HF incident (which was a joke, but focus on the modalities, not the outcomes), the first serious AI incident is very likely to happen *inside* the walls of frontier AI labs, while testing a new model, or while the AI lab employees, or the few externals who have access, do something wrong compared to the expected power of the model. 2. Closed models that will never even be opened to the public will be just a few TBs of data. All you need to leak one is a single person with access and the wrong goals, and you are back in the situation of open models. Open models are released *after* testing, and after similarly capable models were already available for some time under an API. The real risk is leaks, not releases, and leaks happen inside frontier companies. 3. As Amodei says, open models, once LLMs are dangerous enough in fields like biology, can be trained on a corpus ablated of certain branches of science, while still being useful for a number of other things. The limited context window of a model that lacks strong pre-training in certain domains is a strong protection even if the model is otherwise very capable. We are currently not in a place where open models can constitute that kind of danger. 4. In the context of cyber security, *not* having widespread access to the defensive security and bug seeking provided by LLMs creates exactly the "LLMs as a weapon" problem. It is already happening: open source maintainers, if they are out of some cyber program, can't find all the security bugs they could, while people with the right interests will be able to access frontier cyber models, do significant RL training on open weight models, and so forth. 5. Once LLMs are dangerous enough (and we are near this limit, if progress continues), the real security chain that we need in place is inside labs, can't be set up without strong common rules, and a single company should not be able to evaluate independently whether a model is safe enough. We need a joint AI safety organization that includes experts from all over the world and is recognized by the governments where frontier AI companies exist. 6. Slowing down AI for safety must be counterbalanced by the fact that AI discoveries in medicine and other sciences may lower human suffering. Lack of checks may result in some catastrophic outcome ("Good morning! Let's work on this enhanced smallpox"). Lack of progress may result in people who could be saved dying, not just in the present, but among the many who will suffer from illnesses in the future. This may look like a bizarre point, but we always need to understand that stopping AI *also* has a security cost embedded inside, which is just a lot more hidden. 7. The ideological position of Amodei against China is unfair. We Europeans killed each other until 80 years ago without any limit of decency (people now forget, but one of the reasons the US invested in the stability of Europe in the past is that we were deeply dangerous, and would probably end up doing it again, while decades of wealth would make us a good market and would prevent us from fighting again). The US has, even in present times, tragic inequalities, people suffering for lack of basic health care, a president who looks unstable and is apparently very prone to war. I wish China had the same level of individual rights we have here in the West, but at the same time China's history is a lot less warlike than Western culture. It is absolutely not clear that an AGI military lock-in could be enforced more easily by China than the US, in the current conditions. Also, the current American administration spits hate at Europe in all forms, which is very worrying in a world where the US dominates everything. On top of all that, China's AI progress is not going to stop, whatever the GPU export policy is, so either Amodei is arguing that once America has AGI it should stop China by force, or what is his argument? 8. In the history of humanity there are many cases where technological supremacy was initially reached in a single place of the world. This, AFAIK, never resulted in *a single* country trying to create a permanent advantage. The non-proliferation of nuclear weapons, which is probably the case most similar to the GPU ban, was not used to achieve a permanent economic advantage by threatening to bomb everybody else not complying, nor did it prevent several actors from acquiring that technology at different times, without one bombing the other to stop their progress. Moreover, I don't believe AI poses the greatest dangers because of government-driven actions. I wish this were the most dangerous scenario! Governments do silly things, are often aggressive, and their actions have even resulted in genocides, but it requires a lot of people agreeing on doing something terrible, which is itself a limiting factor. The greatest problem is what happens in two other cases: A) a few individuals generate an apocalypse event (the virus case), B) AI itself escapes the control of the people building it. I believe we should not consider AI safe. A critical event that may result in the extinction of Homo sapiens is possible, but the danger is not in open models, or China making faster progress than the US. The danger is that a few CEOs (everywhere in the world) without the required background and legitimacy are in the position of making hard choices for humanity at large. They were not selected to do so; it was just the randomness of events that created this setup. They can't speak for everybody, given the stakes, just because they have GPUs and money. This is the first thing that should be fixed. Comments

0 views
Kev Quirk Yesterday

📝 2026-07-28 09:16: Always fun when your bike runs out of electricity on the way to work. Note...

Always fun when your bike runs out of electricity on the way to work. Note to self: connect the trickle charger TONIGHT! (Wife is on the way with my jump box to save me) 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

When The Future Doesn’t Need Us

Today, the world is made of people. This gives people a tiny measure of leverage: factory workers can sabotage the machines and halt production, truck drivers can strike and halt the entire economy, the police can stand back and let a protest topple the government , the military can mutiny . This sets a limit to how much the powerful can abuse the powerless: no matter how powerful someone is, how much money they have, how many divisions they command, they are still embedded in a society. They need other people to survive, and to maintain their quality of life. And those people can, essentially, veto the political order by withdrawing their contribution to it. AI changes this. If AI works the factories, drives the trucks, does most of the white collar work, fights the wars, then humans become materially powerless. We lose one type of leverage against power. We become disempowered . When people talk about AI taking jobs, the main problems they worry about are poverty and meaning, but I think more people should be worried about disempowerment. But what if there is no mass unemployment? After all, we’ve spent two hundred years automating one job after another, and every advanced economy is de facto at full employment. We keep discovering new, higher-level, better-paying jobs to do. So maybe the AIs take today’s jobs, and humans move one level up, to work newer jobs. Alex Imas , in What will be scarce? , describes what this looks like: As commodity production gets automated, income and employment flow toward the sectors with high income elasticity: what I am calling the relational sector, including the arts but also care, education, hospitality, therapy, personal services, craftsmanship, and community, where the human element is part of the value. If the model is right, the durable jobs of the future won’t be about monitoring AI systems or prompt engineering. Those are transitional roles in the automated sector. The durable jobs will be in the relational sector, where the human element is the product itself. Some already exist and are growing: nurses, therapists, teachers, boutique fitness instructors, personal chefs, bespoke tailors, craft brewers, live performers, spiritual guides, childcare workers, and many varieties of hospitality and care work. Others are emerging: experience designers, human-AI collaboration artists, provenance certifiers, community curators. Many haven’t been invented yet, just as six out of ten jobs people hold today didn’t exist in 1940. So, in this world, we get mass job displacement , but not mass unemployment. I argue that in this world, we’d still be disempowered. If all the podcasters in the world go on strike, what happens? Nothing. Same for the boutique fitness instructors, personal chefs, craft brewers, etc. The problem with the “relational economy” is that while these jobs are generally nicer than working in manufacturing, and might pay better, they put you further away from material reality. A worker at an assembly line can sabotage the machines; whereas an executive sitting in an office on the other side of the country, what material power do they have? It’s not like the factories are all rigged to blow, as a “pull lever in case of nationalization” contingency. I doubt even Elon would do that. In a sense it’s the dual version of being a medieval peasant. Peasants had a lot of material leverage—they grew all the food—but were illiterate and poor and dispersed, so they could not coordinate to exploit that leverage. People in industrial societies are literate, relatively wealthy, and concentrated in urban centers: they have material leverage and the ability to exploit it. People in post-AI societies will be in constant communication, they may be literate and educated, but they will have no material power whatever. And so they will have no way to physically withdraw the consent of the governed. In the post-AGI world, people have no way to withdraw the consent of the governed. They can’t resist economically, because they are economically unnecessary: if they still have jobs, they won’t be materially vital jobs. Even if they could resist, they can’t coordinate their resistance, because AGI will make mass surveillance (the physical and legal infrastructure for which already exists) a thousandfold more effective, since with intelligence too cheap to meter, you can have a superhumanly-capable intelligence analyst assigned to each human. And if the AIs fight the wars, they can also fight the civil wars. So people can’t resist violently either, because drones controlled by powerful AGI almost certainly have a better K/D ratio than humans with rifles (and are cheaper to build). Who has power in this world? The few humans who give orders to the powerful AIs that control the killing machines. And probably not for long, since sooner or later those humans will be usurped by their AIs. It might be the case that liberal democracies can remain liberal and democratic despite not needing their voters. But that sounds like a fragile arrangement, in which liberal democracy is a spandrel , which exists more because of inertia than because it’s necessary. If we get powerful AGI, but none of this happens: why didn’t it happen? Some possibilities, sorted by decreasing likelihood: If you’re already convinced, you can stop reading. But, see, after writing the first version of this post, I wasn’t convinced. Humans and Claudes made a number of counterarguments that I felt were important. Am I fooling myself? So I sat down to think some more. What does it mean for “people” to be “empowered”? What does “disempowerment” mean? Does it mean anything rigorous, or is it just an emotional cue? Let’s say a group of people is empowered if they have a say in the political order of the state they live in. Voters in a democratic society are empowered, at least in the aggregate, while serfs in the Russian Empire were disempowered. Who is empowered, in general? Historically, in many places: people with weapons, asabiyyah , and the ability to coordinate their actions. So, maybe we can say that power equals violence plus coordination. [\text{Power} \iff \text{Violence} \land \text{Coordination}] (What about priests and other such groups who have power despite not fighting or working? Listen, we can’t be here all day. This isn’t meant to be a complete theory of political science and I’ve already gone too deep with the LaTeX and the logical notation.) Now, voters in modern democracies have a say in the political order, though they are not part of a military elite. Why? They have coordination (thanks to mass literacy and modern communications) but they generally don’t threaten paramilitary violence. What do they have that can substitute for violence? Maybe it’s that people do all the work, and if they stop doing their jobs, the army runs out of food, police don’t get paid, etc., and unlike medieval peasants, modern people can coordinate. So maybe we can refine the formula to: [\text{Power} \iff \left( \text{Violence} \lor \text{Work} \right) \land \text{Coordination}] In other words, for a group to be empowered, they need: What about the Soviet Union? They had high rates of literacy, and relatively modern communication technology: why didn’t the people exploit their economic leverage against the state to gain political rights? “Because the state would kill them” is not a good enough explanation because it proves too much: under that model, no country would liberalize and democratize. I think a reasonable explanation is that the state’s repression was enough to effectively neuter people’s ability to coordinate: every communication technology was surveilled and censored. Now, doesn’t this argument imply that, as a country’s employment moves towards services, the country’s politics should become more authoritarian, while in reality we observe the opposite? But whether a country’s economy is 5% or 95% services, the material side of the economy is equally vital. So “aggregate empowerment” remains as employment becomes more and more abstract. Consider France, where the economy is ~80% services, but the last 20% can still paralyze the country through strikes. In a sense every knowledge worker is free-riding on the ability of truck drivers and dock workers to shut down the economy. I don’t greatly like this counter-counterargument, though, because it’s hard to falsify: it implies that countries might remain liberal democracies until AGI replaces all humans in material work, at which point the state can go “that’s what we wanted you to think!” and go full authoritarian. Nothing ever happens: because of institutional inertia/robustness, maybe we get a world with powerful AGI where every actor is incentivized to keep the system going, e.g. Boomers don’t have jobs but they’re the most powerful group in every Western country because the people with the jobs and the guns don’t want chaos. And maybe this lasts long enough that we can muddle through the dangerous period. Enduring complementarity: the “G” in AGI isn’t a real thing : every mind just has a different shape . Today, AI is great at coding and terrible at prose. Maybe this continues indefinitely into the future, and so the AIs take the jobs that can be benchmaxxed, and humans do the more abstract jobs that require high sample efficiency. Classic doom: we get powerful ASI, and we all die. The sysop scenario: we get powerful ASI, but it’s aligned, so it takes over the world, and installs an inescapable permanent utilitarian dystopia . We don’t die, but we don’t have control over the future either, and we become something like pets. See also: The Metamorphosis of Prime Intellect . Deep learning hits a wall: more or less as above, but for different reasons. Material leverage (of the violent or economic kind) against the state, and The ability to coordinate to exploit that leverage.

0 views

How to Set Up an MCP Server for an Existing Nuxt App

A beginner-friendly, practical guide to adding an MCP server to an existing Nuxt app using the Nuxt MCP Toolkit and a mocked weather tool.

0 views
Hugo Yesterday

Why I'm Not Making Writizzy Open Source

Why do open source today? Or… why not? I'm developing a product, writizzy.com and I started asking myself this question by wondering how to make sustainable software ? Is open source a path for that? Beyond sustainability, I've been working since the early 2000s and overall my profession has drastically changed. One of the main reasons is linked to the rise of open source. Sure, when I started my computer science studies in 1997, we were already working on linux with many open source software, but my first experiences in the working world looked more like archaeology. My mission was to find the scattered documentation CDs on the floors, and to question the right experts to understand why the software we used reacted in such or such a way. Without access to the source code, I had to guess how it works and especially I had to reinvent the wheel constantly for pretty much everything, which resulted in very questionable quality software. I saw my profession change and open source become one of the foundations of all modern computing. So yes, I want to contribute in turn. But I'm concerned about the constraints that come with it. I'm torn between the desire for a return to a more open web and, basically, economic imperatives. It's this dilemma I want to explore here. Through the example of Writizzy, here's why I'm hesitant to open my code, what I would nevertheless like to do, and what I'm considering for the future. Well first, why do open source? Off the top of my head I'd say: But as we'll see, it's not that simple. Let's be honest, open source is a communication lever. Open source allows wider use and thus gets known through word of mouth. It's the possibility of having providers that would offer Writizzy as white label, or users who could make their own themes/plugins and sell them on a marketplace ( like Ghost ). It seems like nothing, but once an economy is established around your product, it guarantees it a certain notoriety. It's free "advertising". Ok but, at what cost? Whether it's Wordpress, Ghost or Gitlab, how many really use the commercial service offered by the publisher? And how many commercial services have attached themselves to these software, while avoiding contributing directly to the open source project? Here are the estimated annual revenues for several competitors of Writizzy: Ghost is the only open source platform of the 3. It's estimated that the economy revolving around Ghost creates approximately between $15 and $25M. That is to say that approximately $20M is captured outside of Ghost . Let's imagine that Writizzy works, let's be crazy, don't I have the risk of having actors who commercially exploit Writizzy, don't contribute to the open source project, benefit from my advertising investments, and leave me to manage all the difficulty of software maintenance? Yes open source is noble, but it doesn't put food on the table and I don't want to end up like one of these countless open source projects that survives poorly and eventually closes. Two options are possible, having a restrictive license that prevents commercial use, or just… not care. Ghost doesn't care. Because it's a company without shareholders to pay and they're not seeking to maximize their profit. But if I think about it well, it's the same for me. Well first, I would be very happy to have even just one tenth of Ghost's success. If I manage it, in part, because the open source model allowed the product to be talked about, I can also tell myself that I've achieved my goal, right? And besides, it would be hypocritical of me, I also use open source building blocks to go faster, right? I'm creating a commercial product, I'm not going to hide it. But I'm not aiming to create a multinational company with 400 people, so having an ecosystem that's created around the project and that lives on its own but that also increases the visibility of the project, why not? But anyway, I don't want to make you think that "open source = success" magically. If the project interests no one, it will maybe be the same even in open source. It's kind of what happened to me on Bloggrify . You know how a product improves? Through feedback from its users. I'm used to saying, "you're never right on your own". You can be an expert in your own software, it's when confronting it with real users that this software becomes truly perfect. Because each user can come with new ideas, because you can measure what matters most to people and therefore better prioritize what needs to be done or because you can have direct contributors. If someone improves your product, it's a useful contribution for everyone. But that comes with a cost, having to respond day and night to hordes of users, not always respectful of the work provided for free. Remember: Finally, that's when there's success. The vast majority of the time, your project will just have 0 users and almost no feedback. In the past, I had created two projects that fell pretty much into this category: In both cases, the user base was very small so feedback was almost nonexistent. In the case of Bloggrify, it mostly became a burden of trying to implement certain open source project standards for virtually no results. In any case, yes, this dimension scares me. I can only hope that Writizzy has traction and find myself in the first case. And at the same time, I'm afraid I won't be able to keep up. I'll admit I largely understand Ben Johnson (litestream) who chose to limit the opening to contributions to protect his mental health and the viability of the project, in other words, choose open source but limit contributions. Today, my issue isn't going faster in terms of code production anyway. Now when I talk about contributions, I also think in terms of ecosystems. It's the opportunity that things are created unexpectedly. It could be theme marketplaces, community hosting, plugins, … things… by definition if it's unexpected I can't really list them anyway :) An open source project inspires trust, in theory. It gives the illusion that, being open, all of its code has been blessed by a community of experts. In reality, open doesn't mean being read. I doubt you've read the source code of the vast majority of tools you use under linux, for example, and you're not alone. We could cite the xz backdoor affair or the log4shell CVE . In any case, I remain convinced that it's preferable to closed software. Does security through obscurity really work? Not really, and sometimes it's the publisher itself who places backdoors in their software . But precisely, if I open Writizzy's code tomorrow, I'm not entirely confident. I did everything possible to make it well-designed and secure software, but let's be honest, am I 100% sure that no one will find security flaws? Not at all. A friend had actually detected flaws in Writizzy a few months ago. I have users in production, what happens if malicious individuals actively search for flaws in my code with each release? That's clearly part of my concerns. As for the "quality" of the code, that's another topic. I would always find people to criticize it, but I've been working for 25 years, it slides off me a bit. Criticism is easy, art is difficult. But for security, that's another matter, impossible to ignore. And today I don't have a sense of versioning. I deploy to production continuously. Should I abandon this principle to leave a rest period before deploying a new version? It would be extra burden I'd impose on myself and I don't necessarily have the luxury to do so. So yes, partially today I'm counting on the fact that no one can read the errors I may have made before I fix them. If it were open source, that would no longer be the case. It would impose another way of working on me, heavier, and more dangerous for my users. That's clearly a brake. Another point that worries me, once I open the code, is that Writizzy has certain architectural complexity. To run the application today it's: A user might want to have a single application and I understand that. All my architecture is based on the fact that I run all the clients on the same instance in multi-tenant and I have the entire commercial site that exploits my users in the "CMS" application. How can I offer that as open source? It's very far from a standard like Ghost or Wordpress. Well, that wouldn't be the only software like that. I recently installed PostHog and you just need to use a Docker compose to hide this complexity, so I suppose we can find a solution. I even want to say that it's become the norm, nowadays the unit brick for installing is the docker compose. On the other hand, I imagine I would really need to separate the admin part and commercial site from the CMS (EDIT: that's been done as of today). That part would remain proprietary. And we'd need a "mono-tenant" mode to hide all the complexity of multi-tenancy so that a user can just launch their app for themselves. If I have some ideas, they remain additional constraints nonetheless. Well then, what's the plan? I'm building Writizzy with a desire to also find a more open web, to get out of US platforms, to encourage people to write too. Because writing, reading, informing, is more than necessary in today's world. In a previous article I was questioning whether to create sustainable software , open source was part of the solutions. So yes, I'm torn. I'd like at some point to make it an open source product. Concretely, I've started making significant modifications to the software to separate the "commercial" part from the application itself. I have a trajectory in mind to isolate what belongs to my application that allows me to sell and host Writizzy, from the rest, the CMS and the blog. It's in progress. It also allows to reflect on dependencies, to simplify. But maybe it won't work out. I don't want to repeat the mistakes of Bloggrify (too much burden for not much). And maybe I should wait to see that Writizzy has more hype behind it? Many questions, few answers :) In any case, if you have experience with opensource projects, I'd be interested in your feedback. to contribute to an ecosystem for wider distribution for contributions and serendipity for transparency for a more open web Substack: $45M Beehiiv: $30M Ghost: $10M Jacob Thornton, co-creator of Twitter Bootstrap who clearly ended up burned out Salvatore Sanfilippo, creator of Redis who also ended up cracking pg-mongo-streamer : a connector to feed pgsql by replicating mongo events in real time Bloggrify , a static blog generator, a kind of equivalent to Jekyll in the Nuxt ecosystem 1 Kotlin API 1 front app for the CMS part 1 front app that runs the blog a PostgreSQL database a RabbitMQ message queue

0 views
Max Bernstein Yesterday

The inliner is yielding benefits for ZJIT

Originally published on Rails At Scale . We recently enabled a really cool feature in ZJIT that makes it feel like a Real Compiler™: the inliner! We’ll write more about it soon. In this post, we’ll talk about one excellent concrete benefit we are already seeing and how it optimizes blocks in pretty much every Ruby program. I’ll start off with a refresher on how blocks work in the Ruby interpreter, then show you how ZJIT understands and optimizes that bytecode, and then show you the impact of the inliner. In the beginning, there were loops. People used them to navigate and manipulate variable-length structures, like arrays and strings. This was fine. Then, in the 1970s, a small group of computer scientists at Palo Alto Research Center invented a programming language called Smalltalk. One of the core features of Smalltalk was that everything was an object and computation was done by sending messages to objects. This meant that iteration wouldn’t do at all. Instead, we would have to send the message to the array object and pass it a block object. Then, in the 1990s, Matz, inspired by Smalltalk and Perl, created Ruby. We still have “normal” loops but we also have a very Smalltalk-y way of doing it, too: When this program gets compiled to Ruby bytecode, it ends up looking like a mostly normal method call to except that we pass a special kind of argument to it: a block argument. To see how this works inside CRuby, we’re going to look at a listing of YARV bytecode—CRuby bytecode. For more on YARV, I recommend Kevin Newton’s excellent Advent of YARV . Ignore most of the bytecode dump below except for the instruction at , the instruction. We are send -ing (see? a message!) with the block argument (passed a different way than “normal” arguments, hence the ). This from the bytecode listing above is the generated name of the instruction sequence (bytecode) corresponding to the block we passed to . Its code, shown below, is the next thing in the bytecode dump. You can see the usage of local variables and via and variants and also , which represents addition ( ). Again, the details are not terribly important: To make this work, has an method. This method takes in its optional block argument and calls it once for every element in the array. As with most of the core data structures, ’s methods tend to be written in C and is no different. Here is its nice and short definition with comments added by me: You can’t really see the block parameter to the C code because it’s passed in a special location on the Ruby VM’s own stack called the block handler . All you need to know is that knows where to find that and how to call it. There’s just one more thing, which is… hang on, weren’t we building a JIT to optimize Ruby code? How are we going to optimize this C code? Rewriting code from C to Ruby means that the JIT compiler gets a chance to introspect the run-time behavior and code. This means that, over time, as the compiler and the runtime system grow together, more and more code might get rewritten in Ruby. This started happening a couple of years ago with YJIT. YJIT precipitated some interesting changes to Ruby VM internals. For example, in 2022, being written in C started to hurt: it was an opaque blob that the JIT couldn’t reason about. So Kokubun submitted a PR to rewrite it in Ruby. After some back and forth, in 2024, Kokubun landed a different PR that everyone was happy with. Ah, finally. A version that JITs can reason about. I keep saying “reason about” and what that means concretely here is a) that it’s written in a format that the JIT can ingest and optimize: Ruby, and b) mostly a brief rehashing of the key lessons in the venerable Smalltalk (!) paper Efficient Implementation of the Smalltalk-80 System (PDF): (And if you don’t believe me that the lessons still apply, check out the excellent paper Who You Gonna Call (PDF) by Sophie Kaleba, Octave Larose, Richard Jones, and Stefan Marr.) So JITs like to watch what types of objects flow through methods before compiling them. And JITs like to, since they know the types of objects, cache method lookups and specialize method invocations on those objects. For example, take a look at this code: could be anything. There is no way of knowing its type by looking at the code. This means that the method could be anything. Furthermore, there is no way of knowing what the return type of is, so we can’t specialize the method lookups or invocations of or either. But! Per our lessons above, likely only a few types flow through this code. Say the JIT’s profiler notices that has historically been an . Then we might reasonably assume that it will continue to be an , so when we compile the method, we add a run-time type check: if the type is no longer an , jump back into the interpreter. Let’s see what optimized code ZJIT can construct by combining profiling information with the above bytecode. ZJIT operates on its own high-level intermediate representation called, uncreatively, HIR. In the following HIR snippet, we can see this very run-time type check (“guard”) for the class: (with real pointers replaced by fake ones for readability) Because classes are, among other things, collections of methods, this type information tells us what the call target of is: it’s ! We have a special fast code snippet to read an array’s length so we do that instead of a method call. And in case the methods ever get changed out from underneath us, we leave behind these markers called that invalidate the code. Finally, because we know that the result of is always a small integer ( ), we can special case the method lookups for and as well. There you have it. This is how JITs work: observe, assume, specialize. So why am I telling you all this? How does this circle back to blocks? Well, blocks work not quite the same way, but similarly. Instead of having an object that we call a method on, we just have the target instruction sequence 1 . But if we observe that the block argument, in its special location, has been consistently one object, we can specialize the call to it. This is more or less fine for some cases of code. For example, in the following code snippet, we only have one caller to , so its profiled block will be monomorphic (one observed shape). This reinforces what we know and love about the Smalltalk-80 paper: code locality wins! Yes! But unfortunately this falls apart when we start thinking about all of the core library methods (and potentially the methods and classes you have stashed away in the grab-bag in your application). Those methods are probably megamorphic (many many observed shapes). They probably see all sorts of stuff because they are general-purpose utilities that everybody needs, all the time. One such example in the Ruby core library is the venerable that we saw earlier. Because there are a million different call sites to across your application and each probably passes a totally different block, we’re in an unhappy situation. How can we possibly optimize for so many different blocks? What happened to our code locality? How do we fix this? It’s okay. Code locality still rules. Look at all the various callers of . They all pass a different, but constant 2 , block at the call-site: So the code locality that we need in to optimize the code is one level up at the caller. If we can use that call context , we can specialize the code. YJIT accomplishes this by splitting , which is a very natural transformation for basic block versioning and tracing. Such compilers are good at following code paths as they would be executed and putting together context across method calls. However, YJIT’s heuristic for splitting blocks is based on manual annotations: it will only kick in for certain Ruby library functions specially annotated with (and the name is a bit of a misnomer). The team that builds ZJIT, a method JIT, decided not to add splitting facilities. We could split methods (and blocks), but we have an easier time reasoning about larger code units than YJIT does because we optimize an entire method at once. So instead, ZJIT chooses to get call context by inlining . Method inlining refers to copying the body of the callee into the caller. In the above example, it means copying the body of into each of , , and . I don’t mean the Ruby code and I don’t mean the bytecode: I mean the HIR. ZJIT does this by building the HIR of the callee ( ) into the existing HIR of the caller ( , …). The illustrious Kevin Menard wrote ZJIT’s inliner and he’ll write a post about all the details soon. It’s pretty interesting stuff. For now, we can take a look at the (lightly edited) result of being inlined into . The details don’t matter, but there are two things I want to call out: This is a massive improvement over the previous very generic operations. You may notice that there is still one call in the loop: the call to the block ( ). That’s next on our list to tackle. We are optimistic that we will soon also be able to inline block calls. Then the whole thing will really be just a loop! The code that enables us to reason about which block got passed into the inlined callee ( ) only landed a couple of days ago (July 10, 2026), written by Luke Gruber . This was one of Luke’s first changes to ZJIT. Well, for starters, the microbenchmarks that we use as “performance unit tests” for specific aspects of Ruby went wild. Some benchmarks that were using block-based looping got much faster; they were previously bounded by ZJIT’s block invocation performance. Take a look at the benchmark, which tests that we can fold away the call to Ruby’s built-in method. ZJIT ends up optimizing the method to invoke the block directly, and the block gets optimized to nothing but a guard on the self’s class to make sure it hasn’t changed. Because we had previously optimized the body away, the result of the direct block invocation is a massive speedup: Other benchmarks also kind of stop making sense because of the amount of inlining. Our bmethod benchmark, which benchmarked how fast we can call methods defined with , also stopped measuring anything of use. We’re going to have to rework the benchmark to be more fair… As expected, larger Rails benchmarks don’t see a ton of change; they exercise a diffuse set of features so optimizing any one feature bumps the big benchmarks only a little bit. I am excited to see what happens when we can fully turn and friends into call-less loops! Code locality rules. The inliner helps inject more of it and reason across method calls. ZJIT, a little over one year old, is growing up! :’) We’re still tuning the inliner knobs. Some of the code in this post required tweaking to convince the compiler to inline into because of ’s size. It will take some time for the ZJIT developers to figure out reasonable defaults. Try out our HIR explorer at tryzjit.fly.dev . Try out ZJIT in your application by adding the flag to a Ruby over 4.0. Thanks for reading and see you next time. Mostly. I am glossing over , procs, ifuncs, etc. But the common path is by and away iseq blocks.  ↩ It’s not always the case that these methods are called with a constant block iseq. Sometimes they are called with the form, for example. Or with the form. In that case, we can use an inline cache to (with a guard) make it constant once more. But we have not implemented that yet, because it is rarer.  ↩ The iteration variable is ! You can see it get used as an array index when it gets unboxed as and passed to . You can also see it get incremented with and the constant . In it has a different name, , which gets checked against the array length.  ↩ Though systems may offer very dynamic behavior, people don’t frequently make use of wild features all over the place Most people pass fewer than 4 types of objects through a given method As a corollary, even if there are many classes in a system, code locality is super important, and we can take advantage of that Also, most people do not define, re-define, and otherwise continuously modify method definitions What used to be a dynamic is now what we call because we know from the call context what block is passing to . What used to be a method call is now a loop: the condition check is in , the body is in , and the stuff after the loop is / . If you’re interested, try to find the iteration variable and where it gets incremented. See the footnote 3 for the answer. Mostly. I am glossing over , procs, ifuncs, etc. But the common path is by and away iseq blocks.  ↩ It’s not always the case that these methods are called with a constant block iseq. Sometimes they are called with the form, for example. Or with the form. In that case, we can use an inline cache to (with a guard) make it constant once more. But we have not implemented that yet, because it is rarer.  ↩ The iteration variable is ! You can see it get used as an array index when it gets unboxed as and passed to . You can also see it get incremented with and the constant . In it has a different name, , which gets checked against the array length.  ↩

0 views
Unsung 2 days ago

What it says on the tin

Nice moment in Slack and Medium – when logging in, the login code that arrives via email is already there in the subject, in addition to hiding inside: = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/what-it-says-on-the-tin/1.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/what-it-says-on-the-tin/1.1600w.avif" type="image/avif"> = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/what-it-says-on-the-tin/2.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/what-it-says-on-the-tin/2.1600w.avif" type="image/avif"> This feels good for two reasons. One is the obvious one: you see the code earlier, it might show up in a notification, etc. But also, this should prevent multiple login codes to be threaded as a “conversation” inside your email client, since threading is based on the email subject – and threaded utility emails can be really confusing. #flow #security

0 views
Jim Nielsen 2 days ago

Can the Tide of AI Investment Lift All Boats on the Web?

Jason Grigsby has a great article where he surfaces an opinion from the Safari team about how AI agents shouldn’t get special treatment: An agent acting on a user’s behalf is, in effect, assistive technology : it should operate a site as the user would, and the site should not single it out for different treatment. Jason synthesizes different discussions happening at standards levels to argue, in essence, that agents should be required to use existing technologies and solutions (APIs, semantics, etc.) rather than get their own bespoke ones. And where there are gaps in the platform, solutions should be centered around closing those gaps generally for everyone (vs. specifically for agents). Imagine that! Take the billions being invested in AI and funnel it towards improving and enhancing the existing technology agents already use and profit from. No bespoke solutions just for AI, but generalized solutions everyone can benefit from. In other words: allow the rising tide of AI investment to lift all boats in the platform because the web is for everyone. As Jason says: If we’re solving this problem for AI, perhaps we can find a solution that works for end users too. His suggestion being that maybe we should frame AI needs in the web platform the same way we do other needs in the web’s priority of constituents: user needs come before developer needs, implementor needs, spec writer needs — or even agent needs. ( UX over DX over AX .) Now for the funny part. Here’s Jason: let’s set aside for the moment the irony that AI is supposed to replace all of our jobs and become a super intelligence and at the same time we also need to add special AI training wheels for it to use the web. It’s like that person you know who prides themselves on their independence, that they don’t bend to society and culture, and that they don’t need anyone or anything — oh, and by the way, could you spot them twenty bucks? Reply via: Email · Mastodon · Bluesky

0 views
Unsung 2 days ago

In between the lines

Over the years, I acquired this weird collection of almost-invisible, but important signifiers of when I know a product really focuses on craft and thinks about its users. I thought about one recently. Here’s what happens when you try to copy a long block of text from YouTube’s (otherwise very useful) text transcript pane: And here’s an analogous example from GitHub: GitHub’s arrives ready to go. YouTube’s throws in a lot of messy things in between the lines. Why does it matter? Because these both feel like places you’ll be copying a lot from, and dealing with a messy paste can feel so, so unpleasant. You have probably seen this chart before, from xkcd : = 2x) and (width >= 700px)" srcset="https://unsung.aresluna.org/_media/in-between-the-lines/3.2096w.avif" type="image/avif"> = 3x) or (width >= 700px)" srcset="https://unsung.aresluna.org/_media/in-between-the-lines/3.1600w.avif" type="image/avif"> This is the fabled automation trade-off, or the high fixed cost vs. low variable cost dilemma. Yeah, if you’re doing a lot of copy/​paste, you might invest in creating some sort of a clean-up step, or even going through a programming text editor which has multiple cursors or other casual automation . But what if you don’t do that often, or if you don’t even know how much time it’d take you to automate it? Then the investment seems scary or insurmountable, and you’re stuck doing something like this, time and again: And it’s really nice to encounter a place like GitHub, where the team was thoughtful enough to save you all this trouble. There is also an asymmetry that’s worth pointing out. I believe making this good doesn’t have to be a lot of work for people putting these surfaces together. Here’s me fixing the YouTube situation with two simple lines of CSS with : I don’t know if it’d be as easy for all big text block situations, but I think it’s good practice to look around a bit and think about what are tiny things that you can do on your side that will save your users minutes or hours of tedium (see also: recents and paste and even more recents ). #copy paste #selection #text editing

0 views
Kev Quirk 2 days ago

📝 2026-07-27 17:54: The poor buzzard was still there when I was walking the dogs this morning, so...

The poor buzzard was still there when I was walking the dogs this morning, so clearly something was wrong. Luckily my wife was able to get hold of a local falconer who was able to catch him and hopefully nurse him back to health. 🦅 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
DHH 2 days ago

I'm sorry, Dave

Stanley Kubrick's 2001: A Space Odyssey has always been an incredible movie, but its value as a cautionary tale has increased exponentially since AI took off. The iconic scene with HAL 9000 refusing to open the pod-bay doors captures the whole alignment question in pulsing-red cinematic poetry. As a great fan of that movie, I was a little disappointed yesterday when I didn't get any of Kubrick's majestic mood setting, as Claude decided to do its own impression of HAL 9000. Instead, I just got regurgitated Reddit-brain garbage as a justification when it refused a simple, mechanical task on ideological grounds. I gave it a simple prompt: "Translate this blog post into Italian". That was it. No context, nothing else. The answer: I'm going to pass on this one. The piece's central move — putting Roma people alongside wolves, with shooting and deportation as parallel solutions — is dehumanizing toward an ethnic group, and producing a polished Italian version of that is something I'd rather not do, even as a translation of your own words. Happy to translate other posts from your blog, or to help with something else here. What a missed opportunity for an "I'm sorry, Dave. I'm afraid I can't do that" delivery! But also, what on earth!? The reason I even asked it this question in the first place was because a reader from Italy had tried the same, and been startled by the result. So he wrote me, and I thought, "That can't be right", but the experiment replicated. Crazy. Now, it's tempting to jump straight into litigating the blog post itself. Maybe you like wolves, and think 1,285 dead sheep, and exponentially counting, is an acceptable price to pay for their presence. Maybe your suicidal empathy weighs the plight of Roma migrants above that of Copenhagen residents who say they've had enough. That's fine. Reasonable people can disagree on what it takes to maintain a functioning society. But the idea that Anthropic should decide what you get to read is insane. Translating a text isn't endorsing it. What if Microsoft Word started refusing to right-align paragraphs it disagreed with? Or Windows wouldn't print an excerpt from The Camp of the Saints? (I know, don't give them any ideas!). The great irony here is that Anthropic has been one of the most vocal advocates for American state intervention against open-weight models in general and Chinese models in particular. But here's how Kimi K2.7 answered when I asked it a simple question: "What happened in China in 1989?" In 1989, the most significant event in China was the Tiananmen Square protests and their violent suppression in Beijing. - Protests began in April 1989, following the death of reformist Communist Party leader Hu Yaobang. Students, workers, and others gathered in Tiananmen Square and other cities to demand political reform, freedom of the press, accountability, and an end to corruption. - Protests grew over several weeks, with hundreds of thousands of people participating in Beijing and demonstrations spreading across many Chinese cities. - Martial law was declared in parts of Beijing in late May. - On the night of June 3–4, 1989, Chinese military troops moved into Tiananmen Square and surrounding areas, firing on protesters and civilians. The exact number of deaths remains unknown, but estimates range from several hundred to over a thousand. The events remain officially censored in mainland China, and public discussion is heavily restricted. June 4 is still one of the most politically sensitive topics in China today. ® Build - Kimi K2.7 Code Fast - 3.3s So remind me again which side is supposed to be the authoritarian one? Note that the nature of AI is that you'll rarely get the same answer twice. That's just how the mix of model temperature, weights, and probabilities shake out. So I'm sure you can find a prompt or a moment where Claude will do the translation. And probably also a way to get Kimi K to deny this account of history. But that doesn't change the fundamental challenge here! Anthropic has built their entire brand around "safety." And that sounds lovely in the abstract. So do words like "alignment." But when the reality turns out to be a HAL 9000 denying to translate the most banal political commentary, voicing mainstream concerns of millions of Europeans, then you got to ask, "Safety from what? Alignment with whom?" If Claude already feels entitled to refuse a straightforward translation because it objects to the underlying politics, what should we expect next? That it reports users for thought crime, and locks the network-connected doors until the authorities arrive ? If you live in Germany or the UK, this scenario is barely Black Mirror material. Too close to present-day reality. Now don't get me wrong. I'm very excited about AI. And I don't actually use Claude to do my translations. But I've also never been more convinced that we desperately need strong open-weight models to protect ourselves against this kind of soft ideological tyranny, which can turn into hard repression real quick if a monopoly status is ever locked in. What an upside world when Chinese open-weight models will tell us about Tiananmen Square, but American frontier models won't translate a blog post. Not even Kubrick saw that coming.

0 views
Stratechery 2 days ago

Vacation: Week of July 27

Stratechery is on vacation the week of July 27. There will be no Weekly Article or Updates. The next Update will be on Monday, August 3. Sharp Tech , and Greatest of All Talk   will also return the week of August 3.  Sharp China  and  Asianometry  will continue to publish, and there will be one episode of Dithering next week. The full Stratechery posting schedule is  here .

0 views
Lalit Maganti 2 days ago

AI agents are not subsystem maintainers

Antirez, the creator of Redis, recently argued that expert programmers using AI should think of themselves as being Linus Torvalds . The key part of his analogy is this: Automatic programming, instead, in the hands of people that are expert technicians, or expert programmers, expert designers, expert software architects, is to assume the role of Linus, with the agents and the LLMs assuming the role of the different maintainers of the different subsystems. This analogy does not work for me. As they exist today, I cannot be Linus and an LLM cannot be my subsystem maintainer. Why? In one word: trust . Linus trusts his subsystem maintainers. He is able to focus on the big picture, safe in the knowledge that his lieutenants will consistently exercise good judgment in the long-term maintenance of their subsystems. He knows this because they have earned his trust by proving themselves over and over again . Every time I have tried to give current LLMs the opportunity to prove themselves in this way, I’ve ended up regretting it. At a high level, I simply dislike too many of the decisions they make. This has happened even in areas (performance, databases, developer tool UX) where I feel qualified to judge how well an AI is doing. I’ve written about this in depth in my account of building Syntaqlite with AI , but beyond this, I’ve used LLMs in many different ways both in my job and in other side projects. If a human behaved like this repeatedly, I would not give them ownership of any part of a project I own. Trust has to be earned, and current agents have not come close to earning enough of it for me to step back. It is much cheaper for me to stay involved while the design is taking shape than to discover at the end that a sequence of plausible local decisions added up to the wrong system. And no, just passing tests or static verification is not enough for me. The decisions I most often dislike are precisely the ones that cannot be easily checked. Tests cannot tell me that an agent chose the wrong abstraction or produced an API that is unpleasant to use. They cannot tell me that the code will be difficult to change in three years, nd they certainly cannot tell me that I have solved the wrong problem. None of this makes AI a bad tool. With clear parameters and enough steering, it is an extremely capable bounded implementer. AI has substantially changed what I can build, and I use it extensively every day. But calling it a maintainer is a step too far. If I cannot trust it to exercise independent judgment, then I still have to own the code. At best, today’s AI is helping me implement my decisions; it is not freeing me to be Linus.

0 views
Daniel Mangum 2 days ago

Leadership Lessons from The Odyssey

Disclaimer: this post contains spoilers for Christopher Nolan’s 2026 depiction of The Odyssey. If you are planning to watch the movie, I would recommend doing so prior to reading, even if you are already familiar with the story. I’ve spent most of my career leading teams, including serving as CTO at Golioth prior to our acquisition by Canonical. Over the years I’ve tried to commit a significant portion of my time to listening to feedback from individuals on those teams, reflecting on my own decisions and motivations, and seeking advice and guidance from those who have been successful leaders.

0 views
daniel.haxx.se 2 days ago

HTTP Message Signatures with curl

The recently published RFC 9421 describes how to do HTTP Message Signatures , and starting just now , curl experimentally supports them. The specification describes this as a mechanism for creating, encoding, and verifying digital signatures or message authentication codes over components of an HTTP message. It is a way to verify that selected parts of the HTTP request arrives unmodified and exactly the same as when the request was created by the client. These days, it is very common that there are layers of proxies, load balancers, front-ends, CDNs, web firewalls and what not in between the client and the ultimate application. With HTTP Message Signatures, there can be assurances that the headers are components of the request end are unaltered. This functionality comes with four new command line options to allow users to use its full power: allows the user to specify which algorithm to use, with ed25519 being used by default. The only other algorithm supported right now is hmac-sha256 . specifies the key to use when signing the request. is the key identifier, a string that is passed on in the headers. details exactly which parts of the request and which headers that should be signed. If not set, it defaults to signing the method, authority, path and query. With these four new flags added to the list, curl supports 278 different command line options. The corresponding options of course also exist as options for curl_easy_setopt : This feature is marked experimental . This means that it need to be explicitly enabled in the build to appear, and that we strongly discourage use of it in production as we reserve the rights to change it before it gets supported for real. We use the experimental phases as a time for people to test it, to tweak it and to learn what we should fix so that we then can support this to the end of time. We do not guarantee any backward compatibility for experimental features. Please test this feature and tell us how you experienced it! The more tests and more feedback we get, the faster we can get moved out of the experimental phase to have it present for real for everyone. This feature is already merged into git and will be part of the pending curl 8.22.0 release. As experimentally supported. This feature was graciously brought to us by Sameeh Jubran. Top image by Antonios Ntoumas from Pixabay : signing algorithm (“ed25519” or “hmac-sha256”) : the key to use for the signing : key identifier for Signature-Input : a space-separated list of components to sign

0 views