Dead Code

Jared talks with Noah Silvera, a Super Good Software engineer and the show's most frequent guest, about treating requirements as negotiable rather than as literal instructions. Requirements reach engineers through a game of telephone, so she argues you have to go back to the client, understand the reasoning, and lead them toward better decisions they arrive at themselves. Engineers own the outcome and cannot hide behind "that's just what they told me." She makes the case for spikes, formal or informal, on the grounds that understanding an unfamiliar part of the system first is usually cheaper than fixing it later. Which decisions deserve that investment depends on how expensive they are to undo: design is easy to change in production, while data models require migrations and leave permanent gaps in what you collected. When a launch date will not move and Brooks' Law rules out adding people, the only real lever is cutting scope, which requires knowing what the business actually needs at launch. Her advice to newer developers is that working within constraints is the engineering problem, not an obstacle to it.Links:Brooks' LawThe Mythical Man-MonthSpikeSpikes in SAFeExtreme ProgrammingBig Design Up FrontBoehm's cost-of-change curveTechnical debtGetting Empirical about RefactoringChurn vs. Complexity vs. Code CoverageMinimum viable productSchema migrationDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Charles Nutter has led JRuby for 20 years and still spends much of his time correcting the assumption that running Ruby on the JVM means writing Java. It doesn't. Rails and Hanami apps come over and run, and what you get underneath is world-class garbage collection, real parallel threads instead of 50 forked processes, the Maven Central ecosystem, and profilers you can attach to a live production server. He tells Jared how a $50 Ruby conference in 2004 pulled him out of Java enterprise work and into a project that had been idle since 2001. They also get into the startup time problem and how much recent JVM work has closed it, the compatibility jump through JRuby 10 and 10.1, invoke dynamic, fibers on virtual threads, and what Panama, Valhalla and Project Babylon could mean for Ruby. Charles now funds the work himself through Headius Enterprises after Red Hat's sponsorship ended.Links:JRubyJRuby on GitHubActiverecord-jdbc-adapterHeadius EnterprisesMaven CentralPrismHanamiTruffleRubyProject LoomProject PanamaProject LilliputProject ValhallaProject BabylonDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Host Jared Norman talks with Nik Suresh, who runs Hermit Tech, an extreme programming data consultancy in Melbourne, about why Scrum fails. Nik argues Scrum spread through dishonest marketing (Sutherland's "twice the work in half the time" promise) and that its rituals amplify bad management rather than fix it, from Fibonacci story points that are really just time estimates to one-hour standups he's seen more often than the correct version. His core point is that the map is not the territory: Jira boards and status PowerPoints give executives a simulated cockpit rather than an accurate picture, and he admits he once moved cards to done without doing the work and nobody noticed. He advocates treating any deadline slip as evidence the whole estimate was wrong, paying attention to morale and sick days as the real project signals, and tells engineers stuck in dysfunctional standups to just quit before the environment warps them. His closing lesson is that dropping Scrum alone won't help, since the conditions that produced it will just produce the next silly framework unless teams honestly ask how they came to follow a process on faith.Links:Tossed Salads and Scrumbled EggsPraise The Machine SpiritLudicity (Nik's blog)Hermit Tech (Nik's consultancy)The Agile ManifestoScrum: The Art of Doing Twice the Work in Half the Time by Jeff SutherlandDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

On this episode of Dead Code, Jared talks with Nithin Bekal, a longtime Ruby developer at Shopify, about Sapphire, his hobby programming language: a gradually typed, object-oriented language inspired by Ruby but stripped of metaprogramming magic, implemented in Rust, with features admitted only if he'd use them in production code. Nithin built much of it with LLM coding agents, even prompting from his phone after his laptop died, and now has 10,000 to 15,000 lines of Rust he doesn't fully understand, so he plans to scale back to asking agents questions rather than letting them drive, a struggle Jared relates to after throwing away his own fully vibe-coded OCaml compiler before hand-building his ML-style language, Shroom. Nithin prioritized tooling early because developer experience is what he most wants to learn, cites the LLM-fueled wave of hobby languages like Matz's Spinel and Steve Klabnik's Rue as motivation, advises aspiring language builders to just dive in since parsing is more approachable than it looks, and plans a docs generator as Sapphire's first real codebase.Links:SapphireSpinelRueNithin BekalCrafting InterpretersSorbetRubyRustDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

On Dead Code, Jared talks with returning guest Ismael, a London-based developer who came to programming from fine arts, about event sourcing, CQRS, and the Ruby stack he's built around them. Ismael frames event sourcing as thinking in time rather than space: instead of persisting current state, you keep an append-only log of facts and reduce over it to derive any view you need, which makes gnarly e-commerce discount rules collapse from a sprawling schema into small functions over a flat event stream. His stack includes Sourced (event sourcing), Sidereal (a command-driven web toolkit where forms fire commands into a queue and workers push re-rendered templates back over SSE via Datastar, and notably it isn't tied to event sourcing at all, since the only interface is a plain command struct), and Step (a DSL that yields a running REST API plus OpenAPI docs, tests, clients, and MCP tools from one definition). He's now reworking Sourced around Dynamic Consistency Boundaries, abandoning DDD's aggregate-root God streams in favor of loading only the events needed to validate a specific decision, which cuts lock contention, because consistency is really about the state you used to make a decision. His advice: use Rails Event Store for real work, but to actually understand it, skip frameworks, put event structs in an array, and reduce.Links:Ismael CelisIsmael on BlueskyMy WIP Ruby stack, the post this episode is built onSourcedSiderealSteppeEventlanesDynamic Consistency BoundariesDatastarRails Event StoreEvent Sourcing from the ground up, with Ruby examples, the long-form version of his "just open a Ruby file" adviceBaltic Ruby 2025 talkIsmael's first Dead Code episode, "Event Horizon"Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Tim Riley returns to discuss the launch of Hanakai, a new organization unifying the Hanami, Dry, and ROM projects into a cohesive Ruby ecosystem focused on modern architecture, collaboration, and community. He explains how Hanami 3.0 represents the culmination of years of work, introducing rebuilt mailers, Minitest support, built-in internationalization, significant performance improvements, better logging, and a preview of a language server, while also making the framework more extensible for future growth. The conversation also explores the realities of sustaining mature open source projects through sponsorship, transparent development, and contributor-friendly practices, along with Hanakai’s commitment to inclusive community values, technical diversity, and giving Ruby developers more ways to build applications beyond the traditional Rails path.Links:Hanakai⁠Hanami⁠Dry-rb⁠ROM (Ruby Object Mapper)⁠Hanami 3.0 Release Notes⁠Tim Riley’s Week Notes⁠Contributor Covenant Code of Conduct⁠JRuby⁠gem.coop⁠RubyConf⁠ORCID (Princeton University Libraries Hanami app)⁠Minitest⁠Sidekiq⁠Honeybadger⁠AppSignal⁠FastRuby.io⁠Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Ted M. Young joins Jared to discuss Extreme Programming, predictive test-driven development, event sourcing, and teaching software practices through board games. Ted explains how predictive TDD encourages developers to anticipate exactly how a test will fail, leading to deeper understanding, faster feedback, and smaller development steps. He also argues for thinking about tests as either I/O-free or I/O-dependent rather than unit or integration tests, a distinction that naturally supports cleaner architectures and more maintainable code. The conversation explores Ted’s growing enthusiasm for event sourcing, which he sees as a simpler way to model state changes, preserve history, and reduce complexity around persistence and caching. They also discuss his TDD board game, which has become an effective tool for teaching collaboration, pairing, and software development concepts. The episode closes with a look at AI’s impact on software craftsmanship, with Ted expressing concern that developers may learn less by outsourcing problem-solving to LLMs, while remaining optimistic that core XP practices like small steps, clear goals, and rapid feedback will continue to matter—and may be more relevant than ever.Links:Ted M. Young⁠Predictive TDD⁠Extreme Programming (XP)⁠Test-Driven Development (Kent Beck)⁠Hexagonal Architecture⁠Event Sourcing⁠Domain-Driven Design⁠TDD Game⁠JitterTed on Twitch⁠Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Jared talks with Joan Westenberg about her essay “The Hacker News Tar Pit” and the misconception that AI-powered vibe coding can easily replace established products. Joan argues that while AI can generate software, it cannot recreate the communities, culture, trust, moderation systems, shared history, and network effects that make platforms like Hacker News valuable. The conversation explores how online communities form organically, why moderation and human labor matter more than code alone, and how AI-generated spam is changing the nature of internet communities. They also discuss open source software, the flood of vibe-coded projects, and the psychological effects of constantly comparing your work to what others are building online. Joan ultimately argues that developers should build things because they genuinely want them to exist, not because they expect to disrupt incumbents, while Jared closes by reflecting on an AI-generated compiler he built that worked technically but failed to inspire the long-term interest needed to turn it into a real project.Links:The Hacker News Tar Pit (Joan Westenberg)Hacker NewsLobstersSchelling PointRubyKaigiYukihiro “Matz” Matsumotochorus.fmSomething AwfulDiggCal.comLove2DLuaHindley–Milner Type SystemStudio SelfJoan WestenbergDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Kasper Timm Hansen shares how his post–Rails Core work focuses on small, high-impact Ruby gems built around clear “concepts” rather than loose abstractions, helping developers model domains more effectively and avoid bloated ActiveRecord models. He discusses tools like Associated Objects and ActiveJob::Performs, which simplify structuring data and background jobs while reducing boilerplate, and Oaken, a testing approach that blends fixtures and factories into fast, scenario-driven data scripts. Across all his work, Kasper emphasizes keeping code minimal, readable, and easy to maintain, using constraints like line count to guide design. He also touches on his current project, Peak and gem.coop, where he’s exploring improvements to the Ruby ecosystem such as namespaced gems, dependency cooldowns for security, and better ways to manage and trust dependencies, all driven by an experimental mindset aimed at making development more intuitive and efficient.Links:I quit Rails core 4 years ago, here’s what I’ve been up toKasper Timm HansenRuby on RailsAssociated Objects gemActiveJob::Performs gemOakenActive RecordActive JobFactory BotRails fixturesDelayed JobSingleton classes in Rubygem.coopPeak (gem.coop project)RubyGemsBundler compact indexSupply chain security (overview)Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript