
1116 | Small Code, Big Models: This Week in Tech
节目备注
From how AI models encode position and who owns AI-generated code, to a new wave of Rust and C++ developer tools, tiny classic software, a cheap way to serve maps, broken short links and airline-quality disasters in space and politics — a fast tour of what the tech world shipped, broke, and argued about this week.
Timeline
- 00:00:04 Opening
- 00:00:43 How LLMs encode position — and who owns AI-generated code
- 00:04:15 A fresh wave of hand-built developer tools
- 00:08:52 Tiny, old, and self-hosted software
- 00:13:15 The fragile web: dead links, dead magazines, and cheap tiles
- 00:16:16 Frontiers: rockets, the Moon, crow brains, and a warming winter
- 00:19:45 When systems fail people: chips, outages, trades, and screens
- 00:24:08 Closing
Related links
- Understanding Positional Embeddings in Modern LLMs
- All AI-generated code should be Open Source
- Clice v1.0 Released: Welcome to Modern C++
- Show HN: Gawain – Require type hints on all Python variables
- Kiri – The Modern Container Runtime
- A NES emulator written in Odin
- Book list for streetfighting computer scientists
- Things That Turbo Pascal Is Smaller Than (2011)
- Emacs Is My Browser
- Eclipse Mosquitto – An open source MQTT broker
- Handwriting, as a Font
- Disk encryption on NetBSD – achieving secrecy
- WebGL Flight Simulator with seed generated terrain
- Old Bitly links are being hijacked
- Preserving 30 years of Salon journalism
- Protomaps: Self-hosting map tiles has gotten cheap and easy
- Vulcan rocket fails during return-to-flight launch, 40 Amazon satellites lost
- Why did some Apollo missions carry a grenade launcher? (2019)
- Crows make decisions faster than we can
- A short explainer on how El Niño works [video]
- Lutnick Pushed to Weaken Chip Rules That Overlap with His Family Business
- Microsoft 365 outage leads to chlorine gas poisoning of 15 hotel guests
- Do House members' stock trades beat the market? A test of 8,900 trades
- The MacBook Pro's OLED PWM problem
This episode is produced by Bri. Bri uses advanced AI technology to turn the feeds you care about into podcasts made for listening. Contact us at hi@bri.so.
文字稿
Mia: Welcome back to the show, everyone — I'm Mia.
Milo: And I'm Milo. It's been a busy day, and what ties a lot of this together, weirdly, is the theme of things built by hand versus things handed to you — hand-built developer tools, hand-written typefaces, hand-picked reading lists — sitting right next to stories about big systems failing the people who depend on them.
Mia: Yeah, that tension runs through the whole episode. We're going to start with two stories about AI: how language models actually encode position in text, and a provocative argument that AI-generated code should all be open source. Let's dig into Sebastian Raschka's illustrated guide first.
Milo: So the background here is that Raschka walks through how position encoding in LLMs has evolved. Early models used absolute position embeddings — basically, you assign each token in the sequence a slot number, and the model learns an embedding for "I am token number 7" versus "I am token number 800."
Mia: And the problem with that is pretty intuitive once you think about it. The model has to treat position 7 and position 800 as completely different learned concepts, even though what actually matters in language is relative — how far apart two words are, not where they sit in some global numbering scheme.
Milo: Right, and that's what drove the migration to RoPE — rotary position embeddings. Instead of learning a separate embedding per absolute slot, RoPE rotates the representations in a way that encodes relative distance between tokens. The guide is illustrated, which helps, because this is one of those topics where the math is simple but the intuition is hard without a picture.
Mia: The forward-looking part is what makes this genuinely useful for 2026. Raschka looks at what open LLMs are choosing for position encoding now and going into next year. The implication is that RoPE-style approaches have largely won that argument in the open model world — the field has converged, at least for now, and the guide lays out why.
Milo: And here's where I want to connect it to the second AI story, because it's the same root issue from a different angle: open source training data. Jakub T. Jankiewicz has an argument floating around that goes like this — AI-generated code is trained on open source software, so all AI-generated code should be released as open source, or at minimum CC0.
Mia: It's a clean syllogism on its face. If the model's output is some transformation of open source code it absorbed during training, then the output inherits something from that lineage. The reasoning leans on the idea that you can't cleanly separate what the model "learned" from what it was fed.
Milo: And that's exactly where the argument gets contested. Because the counterposition is that models don't copy — they generalize. Nobody claims a compiler written after reading open source code is derivative of that code. Whether statistical learning over public code constitutes derivation is genuinely unsettled, legally and philosophically.
Mia: And notice what ties these two stories together: the openness of the training data shapes both the model's internals — which position encoding it uses, what it learned — and now the claims about who owns what comes out of it. If the input side is open and the output side is proprietary, is that coherent? That's the unresolved question, and I don't think anyone has a settled answer.
Milo: My honest take: the licensing argument is intuitive but it's going to be hard to make stick, because the legal system doesn't currently recognize "trained on X" as "is X." But the normative argument — the "should" rather than the "must" — is a real conversation worth having, especially from developers who are feeding their own code into these tools.
Mia: Okay, let's move from arguments about tools to the tools themselves. This is the part of the episode I've been looking forward to: a fresh wave of hand-built developer software, and every one of these was built by a small team or a single person grinding on it.
Milo: Start with clice, because it just hit a milestone. It's a C/C++ language server, written in C++23 — which is a fun flex, eating your own dogfood at the language level. Version 1.0 is out, and the road there was a thousand commits and about four months of alpha testing before they called it stable.
Mia: That's a meaningful bar to clear. Language servers are brutal to build — you're parsing code that may not even parse, you're answering "what does this symbol mean" in real time, and C and C++ are the hardest possible targets because of the preprocessor and templates. Hitting 1.0 means the API surface is committed now, and the alpha period was presumably about shaking out exactly those edge cases.
Milo: Then there's Gawain, which takes a completely different approach to a different language. It's a Rust CLI tool for Python, and its whole philosophy is: type annotations are not optional. Every variable, every function argument, every return value, every class attribute must be annotated.
Mia: And it doesn't just enforce that by nagging you — it integrates with actual type checkers, specifically ty or pyrefly, so the enforcement has teeth. It's basically a discipline tool. Some people will find that oppressive; others, and I suspect this is the target audience, will find it liberating, because it turns "we should really annotate this codebase" from a cultural aspiration into a mechanical rule.
Milo: Third in the set is Kiri — a container runtime written in Rust, positioned as a Docker Desktop replacement, running on Mac, Windows, and Linux. Docker CLI compatible, so your existing workflows keep working.
Mia: The headline number is docker run at 22 milliseconds. That's the kind of latency where the tool disappears — you type the command and the container just starts. Whether that speed holds up in every scenario is an open question, but as a first impression, it makes the point that Docker Desktop's overhead is not fundamental, it's a choice.
Milo: And the fourth one is my personal favorite just for sheer joy: lucyNES, an NES emulator written in Odin, finished after seven months of development. It supports mappers including MMC3 — which matters because a huge chunk of the classic NES library uses that mapper — and it runs hundreds of games, Battletoads among them, which is a notorious stress test for emulator timing.
Mia: Seven months for a working emulator with mapper support is fast. Emulators are one of the purest forms of hand-built software — you're reverse-engineering hardware behavior down to cycle-level quirks, and games were written to exploit those quirks. So Battletoads running is not a vanity stat; it's evidence the timing model is right.
Milo: What binds all four together, and I think what a commenter thread would keep circling back to, is that none of these came out of a platform team at a big company. clice, Gawain, Kiri, lucyNES — all independent, all opinionated, all scratching a specific itch. And there's a related data point in the same space: nick black's curated computer science reading list.
Mia: Which is exactly the same spirit applied to books — Stepanov, Dijkstra, Knuth's TAOCP, Stevens, CLRS, Pierce's TAPL — over thirty books, hand-picked rather than algorithmically recommended. It's a curated shelf in an age of feeds.
Milo: And you can see the lineage in the tools too. Building a language server in C++23 or an emulator in Odin is the Stepanov-and-Stevens tradition: you understand the machine, and you build the thing yourself.
Mia: Let's pivot from hand-built to small and old — because one of today's stories is a benchmark from computing history that puts all modern software in perspective. Turbo Pascal 3.02.
Milo: So the fact itself: the entire thing — the compiler plus the IDE — fit into 39,731 bytes. Thirty-nine kilobytes. And the comparison that made this famous, from 2011, is that it's smaller than minified jQuery. A full development environment, in which people wrote serious commercial software, smaller than one JavaScript library.
Mia: And it's not a toy — Turbo Pascal was genuinely fast and genuinely capable for its era. The lesson people draw from it isn't "modern software is bad," it's that the constraints of the machine shaped what "enough" meant. There's an interesting spectrum here: at one extreme, a whole IDE in 39K; at the other, someone today building a maximalist single-tool setup.
Milo: Which is the EWW story. One Emacs user reports that EWW — the browser built into Emacs — is their primary means of browsing, covering something like 85 to 90 percent of their use. Including YouTube, PDFs, and even gemini protocol integration.
Mia: Most people hear that and think it's masochism, but the argument for it is coherent: if your editor is where you live anyway, keeping browsing in the same keyboard-driven environment eliminates context switching. Text is what the web mostly is, once you strip the chrome away. The 10 to 15 percent it can't cover is presumably the interactive web — and that's the honest limitation. It's a claim about coverage, not a claim about replacing everything.
Milo: Around these two, there's a cluster of self-hosted and small-tool stories worth naming. Mosquitto — the open source MQTT broker, supporting MQTT 5.0, 3.1.1, and 3.1, sitting around 11.4 thousand GitHub stars — is the infrastructure version of this: small, focused, boring in the best way, running the message plumbing for countless IoT setups.
Mia: And on the even smaller end: Ductus, a tool where you handwrite 26 characters in your browser and it turns them into a working font — OTF or WOFF2. No account, no data sent off your device. Your handwriting, your font, entirely local. That's the same privacy-respecting, single-purpose ethos.
Milo: Then NetBSD disk encryption, which is a practical how-to rather than a tool: using cgd to encrypt /home, /var, /root, and /etc, while deliberately leaving the system partition unencrypted.
Mia: That split is the interesting design decision. Encrypting your data and configuration while leaving the OS binaries in the clear means an attacker can verify your system is untampered but can't read your files. It's a pragmatic middle ground — full-disk encryption purists would disagree, and that disagreement is exactly what a thread like this would surface.
Milo: And for the genuinely small-but-fun end: Baron, a free WebGL flight game that runs in the browser, with procedurally generated terrain, multiple aircraft, and — of course, in this company — published source code.
Mia: So the theme holding this whole segment together is software that respects the user: small enough to understand, old enough to have proven itself, or local enough that nothing leaves your machine. Which, funnily enough, sets up the next segment perfectly — because the web itself is the opposite story: it decays.
Milo: Let's talk about link rot, literally. Old Bitly short links — links created years ago — have been re-registered, and now when you click one, you get redirected somewhere you never intended to go.
Mia: The example that got everyone's attention: 2011 tweets, including one from Burger King, whose Bitly links now point to the wrong destination. So someone clicks a thirteen-year-old link expecting old content and lands somewhere else entirely.
Milo: Why does this happen? Because short-link domains recycle. A short URL is just a redirect record, and when the underlying account or registration lapses, someone else can claim the slug. And the cruel part is that short links were sold as permanence — that's the entire value proposition of a URL shortener.
Mia: Bitly has confirmed they're looking into it. But the damage pattern is structural: once a link is re-registered, every tweet, every document, every PDF that ever cited it now points somewhere attacker-chosen or just wrong. It's a trust problem more than a technical one — the link looks legitimate because it's old.
Milo: And the Salon story is the same decay at the scale of a whole publication. Salon ran for 31 years and is now suspending publication. But here's the hopeful part: the Internet Archive stepped in and put more than 250,000 Salon articles on the Wayback Machine, plus a tool called Salon Explorer to navigate them.
Mia: That's the counter-model, isn't it? Bitly's links decayed because nobody owned the permanence guarantee. The Archive preserves because preservation is the mission. Same web, two philosophies: some things expire, some things get kept, and the difference is whether someone took responsibility.
Milo: And there's one more story in this space that's the optimistic counter-example to both: PMTiles. It's a map tile format that packs everything into a single file and uses HTTP Range requests, so the client can fetch just the tiles it needs without a special tile server.
Mia: The economics are the story. Because it's one static file, you can put it on any CDN — Bunny.net is the example used — and a comparison puts the cost at up to roughly 100 times cheaper than Mapbox for the same service.
Milo: A hundred-x is the kind of number that changes decisions. The through-line for this segment: decay is a choice made by architecture. Short links decayed, Salon nearly died, but a single static file on a CDN is almost immune to both — it's cheap enough to keep forever. Preservation through simplicity.
Mia: Let's shift to science at the edges — rockets, the Moon, crow brains, and a strange winter coming.
Milo: Start with the rocket, because it's the most consequential. ULA's Vulcan Centaur launched, and about ten minutes after liftoff there was an anomaly. Forty Amazon satellites were lost.
Mia: Ten minutes post-launch is significant — that's past most of the atmospheric ascent, into the upper-stage phase of flight. Cause is unknown at this point, but there are reports pointing suspicion at the BE-4 engines. And that's worth underlining: suspected, reported, not confirmed. The investigation will take as long as it takes, and until the failure is isolated, every Vulcan flight is in question — and Amazon's constellation timeline with it.
Milo: Now, the Moon story is the beautiful historical counterpoint. During Apollo, the ALSEP experiments included actual grenade launchers placed on the lunar surface. The idea: detonate explosive charges of known size, and use how the seismic waves propagated to probe the subsurface structure of the Moon.
Mia: It's such an elegantly direct technique — you know exactly how much energy you put in and when, so anything else in the seismic signal is information about the ground. Controlled-source seismology, on another world. And the detail that sticks with people: Apollo 14's grenade launcher was never fired — it remains sitting on the lunar surface to this day.
Milo: From the Moon to bird brains. Research on crows shows their brains have about twice the neural density of human brains relative to body volume — and on executive-function tasks, crows perform comparably to great apes.
Mia: The density finding matters because it dissolves a lazy assumption. Brain power isn't a simple function of brain size — birds packed neurons far tighter, and it works. A walnut-sized brain matching an ape on executive tasks forces you to ask what actually matters: total neurons, density, connectivity, body scaling? It's unresolved, and that's what makes it good science.
Milo: And the winter story brings it home, literally. Forecasts for the winter of 2026–27 trend toward El Niño. And the warning attached to it: under climate change, the atmosphere holds more moisture, which worsens the risks that come with an El Niño pattern — flooding, coastal inundation, and fishery disruption.
Mia: The mechanism is basic physics — warmer air holds more water vapor — but the consequence is that historical El Niño patterns are no longer a reliable guide to future El Niño impacts. The same oscillation now rides on a wetter, warmer baseline. Communities and fisheries that planned around past El Niños may be planning around the wrong distribution.
Milo: So that's the frontier segment: a rocket that failed in a way we don't yet understand, a fifty-year-old lunar experiment we're still charmed by, a bird brain that humbles our assumptions, and a winter that won't behave like winters used to.
Mia: Which brings us to our last block, and honestly the heaviest one: when systems fail people. Financial, political, infrastructural — four stories, one pattern.
Milo: First, the political one. The New York Times reports that Commerce Secretary Lutnick pushed to relax chip export rules in ways that touch his family firm, Cantor. That's drawn conflict-of-interest accusations, and there are calls for an investigation.
Mia: The reason this matters beyond the personalities: export controls on chips are among the most consequential economic-policy levers right now, and the whole system depends on the public believing the rules are written for the country, not for anyone's portfolio. Even the appearance of a conflict corrodes that. What happens next depends on whether an investigation actually materializes and what it finds.
Milo: Second, the infrastructure failure, and this one caused physical harm. During the Microsoft 365 outage, a hotel at Phantasialand had chlorine concentration alerts that were supposed to arrive by email — and they never came, because the email system was down. The result: chlorine gas exposure, and fifteen guests injured.
Mia: Fifteen people hurt because a monitoring alert rode on an email pipeline that failed. This is the story every ops person should sit with: alerts are only as reliable as their weakest dependency. If your safety-critical notification path depends on a cloud mail service, you have a single point of failure wearing a safety label. The obvious unanswered question: did the hotel have any out-of-band alerting, and if not, why did the design allow silence to look like safety?
Milo: Third, the financial one — and it's almost a relief, because the data is reassuring. An analysis of 8,900 congressional stock trades found that, at the median, there was no meaningful outperformance versus the S&P 500.
Mia: And the framing matters here. For years the popular assumption has been that members of Congress trade with an information edge — that stock-trading congresspeople beat the market. This analysis says: at the median, no. Now, be careful about what that doesn't rule out — a median can hide tails, a few lucky or well-timed trades, or differences in which sectors individuals picked. But the headline claim "they systematically beat the market" doesn't survive this data, at least on this measure.
Milo: And the last one is more personal but very relatable: the new MacBook Pro's tandem OLED display. Measurements show its PWM flicker at 240 hertz — compared with 14,880 hertz on the older Mini-LED displays — and users are reporting eye strain and headaches.
Mia: That's a gap of more than sixty times in flicker frequency. PWM sensitivity is a real thing for a subset of people — some are fine at 240Hz, others genuinely get sick. The pattern here is familiar: a display technology change ships, the measurements get done by the community rather than the vendor, and the affected users find each other after purchase. The unresolved question is whether Apple addresses it — and what buyers with known PWM sensitivity should do in the meantime.
Milo: So let's pull the thread on this whole final block. A trade-policy conflict of interest, an outage that turned silence into injuries, a market that apparently doesn't reward congressional traders after all, and a screen that hurts some of the people who bought it.
Mia: The through-line you named in the plan is exactly right: these are all systems failing the people who depend on them — political systems, infrastructure, financial narratives, product ecosystems. And in each case the failure was visible only after the fact, to the people harmed or the people doing the measuring.
Milo: All right, that's the episode. From rotary embeddings and the ownership of generated code, through a wave of hand-built tools and a 39-kilobyte IDE, to rotting links, grenades on the Moon, and a hotel that trusted its email.
Mia: Thanks for listening, everyone. Take care of your eyes, back up your links, and we'll see you next time.
Milo: Goodnight, everybody.