Dead Code

Jared Norman

The software industry has a short memory. It warps good ideas, quickly obfuscating their context and intent. Dead Code seeks to extract the good ideas from the chaos of modern software development.

Hosted on Acast. See acast.com/privacy for more information.

Play

Open in

25 episodes
fortnightly
Avg 39 min
English

Episodes 25

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

#77
Tuesday · 39 min
Rust in Pieces (with Alistair Norman and Sofia Besenski)
On this episode of Dead Code, host Jared talks with Sofia Besenski and Alistair Norman of Super Good about DHH's 2026 Rails World keynote. In it, DHH announced that HEY is leaving Rails for six native apps and a Rust backend. He has called Rust hideous before, but he now argues that the language's looks don't matter because agents write the code and he doesn't read it. The panel doubts that six apps beat one good web app. Sofia warns that teams leaning on agents build up "cognitive debt" and lose track of how their systems work. Alistair says most people don't want more apps on their phones. All three dismiss DHH's lines-of-code numbers as meaningless. Jared reads José Valim's reply, which asks why DHH didn't use these tools to improve Rails itself, and the hosts point to other Rails World talks on Active Search, Herb, and Ractor safety that did move the framework forward. Links: Rails World 2026 Opening Keynote - DHH Rails World 2026 agenda and talks What About Rails? Hardly Promethean HEY Omarchy José Valim's reply on X Active Search talk by Donal McBreen Active Search on GitHub Herb Aaron Patterson's closing keynote On Rails: Aaron Patterson on Ractors, JIT compilers, and rewriting how gems install Steven Shaw and Gideon Nave on cognitive surrender (Wharton) Martin Fowler's Design Stamina Hypothesis Mosscap Hanami Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#76
September 28 · 25 min
Where the Bodies Are Buried (with Kerri Miller)
Jared talks with Kerri Miller, a Staff Engineer at GitLab, about Keela. It's her new open-source tool that finds unused code in Rails apps, and it's named after a UK police dog known for finding buried bodies. It began about three years ago as an attempt to cut GitLab's CI costs. Kerri didn't want a tool that deletes dead code all at once, so Keela uses regex to snapshot the methods it thinks are unused and fails the build when someone adds new dead code. An exclusion file handles false positives. So far the work has removed about 290 methods and saves GitLab around $150,000 a year in CI costs. Kerri has shipped five releases in six weeks, and partials are next on her list. Links: Keela Kerri Miller on GitHub Sponsored Logs Rubydex TOON Lefthook Seattle.rb GitLab Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#75
September 15 · 32 min
None Dare Refactor (with Noah Silvera)
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' Law The Mythical Man-Month Spike Spikes in SAFe Extreme Programming Big Design Up Front Boehm's cost-of-change curve Technical debt Getting Empirical about Refactoring Churn vs. Complexity vs. Code Coverage Minimum viable product Schema migration Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#74
September 1 · 39 min
Bound for Valhalla (with Charles Nutter)
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: JRuby JRuby on GitHub Activerecord-jdbc-adapter Headius Enterprises Maven Central Prism Hanami TruffleRuby Project Loom Project Panama Project Lilliput Project Valhalla Project Babylon Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#73
August 18 · 51 min
Dragged Into Done (with Nikhil Suresh)
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 Eggs Praise The Machine Spirit Ludicity (Nik's blog) Hermit Tech (Nik's consultancy) The Agile Manifesto Scrum: The Art of Doing Twice the Work in Half the Time by Jeff Sutherland Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#72
August 4 · 25 min
No More Magic (with Nithin Bekal)
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: Sapphire Spinel Rue Nithin Bekal Crafting Interpreters Sorbet Ruby Rust Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#71
July 21 · 45 min
Twilight of the Object God (with Ismael Celis)
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 Celis Ismael on Bluesky My WIP Ruby stack, the post this episode is built on Sourced Sidereal Steppe Eventlanes Dynamic Consistency Boundaries Datastar Rails Event Store Event Sourcing from the ground up, with Ruby examples, the long-form version of his "just open a Ruby file" advice Baltic Ruby 2025 talk Ismael's first Dead Code episode, "Event Horizon" Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#70
July 7 · 38 min
Bloom of the Undying (with Tim Riley)
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: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#69
June 23 · 51 min
Altars of Append (with Ted M. Young)
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: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#68
June 9 · 27 min
Toxic Deluge (with Joan Westenberg)
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 News Lobsters Schelling Point RubyKaigi Yukihiro “Matz” Matsumoto chorus.fm Something Awful Digg Cal.com Love2D Lua Hindley–Milner Type System Studio Self Joan Westenberg Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#67
April 21 · 39 min
Seeds of Devastation (with Kasper Timm Hansen)
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 to Kasper Timm Hansen Ruby on Rails Associated Objects gem ActiveJob::Performs gem Oaken Active Record Active Job Factory Bot Rails fixtures Delayed Job Singleton classes in Ruby gem.coop Peak (gem.coop project) RubyGems Bundler compact index Supply chain security (overview) Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#66
April 7 · 19 min
Felony CSS (with Lyra Rebane)
In this episode, Jared talks with security researcher Lyra Rebane about pushing CSS far beyond its reputation as a simple styling language, exploring how modern features like nesting, advanced selectors, and state-based logic enable complex interactivity without relying on JavaScript. Inspired by experiments on Cohost, Lyra created projects like a fully CSS-based clicker game and even an 8086 CPU emulator that can run compiled C code using CSS variables, animations, and clever workarounds. The conversation highlights how developers often overuse JavaScript for tasks CSS can handle more efficiently, while also challenging the industry’s tendency to dismiss CSS work as less valuable, arguing instead that treating CSS as a true programming language opens up both technical possibilities and greater respect for front-end expertise. Links: Cohost platform CSS nesting :has() selector CSS variables (custom properties) CSS animations CSS container queries Cookie Clicker (incremental game example) x86 architecture overview 8086 CPU C programming language Content Security Policy (CSP) Cross-site scripting (XSS) SVG filters Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#65
March 24 · 39 min
Reject Modernity (with David Copeland)
In this episode of Dead Code, Jared talks with developer Dave Copeland about his article “The Death of the Software Craftsman,” which reflects on how AI coding tools are reshaping the role of programmers. Copeland describes a personal reckoning with whether traditional programming skills still matter in a world where AI can generate large amounts of code. He outlines three possible responses for developers: refusing to use AI, going all in on AI-assisted development, or “embracing tradition” by positioning oneself as a craftsperson who writes higher-quality code by hand in areas where reliability and accountability matter. The conversation explores the tension between programmers who enjoy the craft of coding and businesses that primarily care about outcomes, suggesting that as AI becomes more common, developers may need to focus less on code elegance and more on measurable results like reliability, safety, and system performance while learning how to work effectively alongside AI tools. Links: The Death of the Software Craftsman Dave Copeland Brut Ruby Web Framework Ruby Programming Language Ruby on Rails Software Craftsmanship Movement SOLID Principles Dependency Injection Cross-Site Request Forgery (CSRF) Agile Software Development Observability in Software Systems Large Language Models (LLMs) Accidental Tech Podcast Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#64
March 10 · 27 min
Frankenstein’s System (with Sean Goedecke)
Sean Goedecke contrasts generic design advice (principles and patterns not grounded in a specific codebase) with concrete design (decisions shaped by the real code, constraints, and existing “prior art”), arguing you can’t meaningfully design software you don’t work on because you lack the context to make implementable calls. Generic advice has its place (greenfield work, company-wide guardrails), but in large, messy systems consistency matters more than isolated “good design,” because teams survive by reusing known patterns and keeping the codebase coherent. He’s skeptical of architect handoffs where designs ignore practical timelines and incentives reward complexity, and he notes AI coding tools behave like smart outsiders—useful, but prone to reinventing what already exists unless humans with deep context guide them. Links: Sean Goedecke’s article: “You can’t design software you don’t work on” SOLID principles (overview) Single-responsibility principle (SRP) GitHub Copilot (product page) GitHub Copilot code review (docs) Claude Code (Anthropic product page) GitHub adding Claude + Codex agents (The Verge) Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#63
February 24 · 34 min
Indistinguishable From Evil (with Russ Olsen)
Jared interviews veteran programmer and author Russ Olsen about updating Eloquent Ruby for the last 15-ish years of Ruby evolution, from how he discovered Ruby while trying to teach his young son to code (anything but Java) to how Rails suddenly made Ruby mainstream and pushed him into writing. They unpack what “eloquent” Ruby means: solving problems with minimal fuss, staying concise but clear, and treating code as both a working machine and readable literature, plus why the book is structured from tiny examples up to larger systems to help experienced programmers learn Ruby fluently. Russ discusses newer language features like keyword arguments and pattern matching (fun, but not widely used yet), argues for a more tempered, cost-benefit approach to metaprogramming, and shares skepticism about optional static typing in Ruby (RBS/Sorbet) except at key boundaries in very large codebases. The episode closes on Russ’s “Technology as if People Mattered” philosophy and how Ruby’s community culture, often credited to Matz, reflects that human-centered mindset. Links: Eloquent Ruby, Second Edition (beta/book page) Pragmatic Bookshelf beta catalog Russ Olsen’s blog: “Technology As If People Mattered” Russ Olsen (about page) Overdrive by Russ Olsen RBS (Ruby type signatures) on GitHub Sorbet (Ruby type checker) docs Ruby pattern matching documentation TruffleRuby documentation (GraalVM Ruby) Ruby Regexp documentation Dead Code Episode: “Pickaxe Resurrection (with Noel Rappin)” Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#62
February 10 · 43 min
The Slop Slope (with Daniel Fichtinger)
Jared interviews CS and cybersecurity grad student Daniel Fichtinger about “slopware” in open source. These are projects, often boosted by AI, that perform legitimacy with buzzwords, emoji feature lists, templates, donation links, and sweeping claims, while the underlying code is messy, over-scoped, or not actually delivering what the README promises. Daniel argues the issue is not simply “bad code” or “used AI,” but honesty, scope, and whether the maintainer can explain and maintain the work. Good projects make a strong first impression through humility, clear boundaries, and sometimes explicit limitations or alternatives. They reframe “gatekeeping” as community maintenance, a social contract of not wasting others’ time, using a gardening metaphor where slop spreads like weeds and harms beginners most by teaching bad patterns. Daniel describes stopslopware.net as a linkable educational response to repeated spammy posts and offers rehab steps: rewrite your README yourself, then incrementally replace AI-generated parts until you genuinely understand and can stand behind the whole project. Links: stopslopware.net ficd.sh Daniel’s blog Lobsters The XY Problem Motherfucking Website Crafting Interpreters Codeberg Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#61
January 27 · 49 min
Zero Specificity (with Stephen Margheim)
Jared talks with Stephen Margheim about a “missing” middle layer in modern design systems: reusable CSS affordances that sit between Tailwind utilities and full components. Stephen shares how building a no-JavaScript half-star rating input (radio buttons + labels + SVG + careful hover/layout CSS) reinforced his bias toward solving problems with the smallest toolset to avoid incidental complexity and to make solutions portable across frameworks. That philosophy leads to his critique that components are a poor vehicle for purely visual styles because they bundle structure, behavior, and aesthetics in ways that are hard to reuse—so instead, teams should name and standardize visual signals like “button” as composable classes that can apply to many semantic HTML elements. He explains how Tailwind can support this via custom utilities (@utility), tree-shaking, autocomplete, variants, and low-specificity defaults using :where(), and argues a four-layer approach—tokens → utilities → affordances → components—helps teams maintain design systems and progressively drop JavaScript as the web platform adds more native UI primitives (dialog, popover, details/name, etc.). Links: fractaledmind.com Web Awesome Font Awesome Tailwind: Introducing Catalyst Catalyst docs shadcn/ui daisyUI Tailwind docs: Functions & directives MDN: :where() selector MDN: Popover API MDN: CSS anchor positioning MDN: <dialog> element MDN: Invoker Commands API MDN blog: Exclusive accordions with <details name> web.dev: Interop 2026 proposals Ruby on Rails SQLite Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#60
January 13 · 46 min
IDE-cide (with Samir Talwar)
In this episode, Jared is joined by Samir Talwar to talk about why “programming peaked” and how the developer experience has arguably regressed over the last 15 years—from losing powerful IDE refactoring workflows to the ways pull requests can turn into delayed integration. They dig into what teams lost when testing became “everyone’s job,” why reviews often get stuck in surface-level diff commentary, and how pairing (with rotation) can restore earlier feedback and shared context. They also get into infrastructure trade-offs: containers and Let’s Encrypt are huge wins, but Kubernetes and other “Google-scale defaults” can add heavyweight complexity for teams that don’t actually need it. Links: Samir Talwar (site) “Programming Peaked” (Samir’s post) Language Server Protocol (LSP) Visual Studio Code Vim Continuous integration (Martin Fowler) Extreme Programming (XP) Pull requests (GitHub docs) Kubernetes Docker Let’s Encrypt Mastodon Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#59
Dec 30, 2025 · 38 min
Death From Algorithm W 1978 (with Sabine Schmaltz)
Jared talks with Sabine Schmaltz, an OCaml Developer Advocate at Tarides, about how she went from learning Standard ML in a demanding university course to getting hired for an OCaml role despite only having written “Hello, World,” and what she’s building now: FeedMansion, a tool to improve multi-account social posting and make OCaml community content more engaging with better summaries/teasers. Sabine explains her pragmatic stack—an OCaml backend using the minimalist Dream framework, a SolidJS frontend, and OCaml-based static site generation with MLX (a JSX-like approach that gives type-checked HTML)—and notes that OCaml’s syntax can feel foreign, which is part of why projects like Reason/ReScript help. They dig into where the real friction is today: not OCaml itself, but managing LLM-assisted coding responsibly, dealing with tooling/documentation transitions (like keeping agents on Dune instead of older opam-first guidance), and handling cases where LLMs stumble—such as complex typed database queries—where she used OCaml’s PPX system to generate safer code. The conversation widens to community building via FUN OCaml (Berlin 2024, Warsaw 2025, planning 2026), what’s new in OCaml (multicore support and effect handlers), the value and risk of AI-generated open source contributions, and Sabine’s advice for introducing OCaml at work: start small, choose problems where OCaml shines (DSLs/codegen, reliable services), and help the ecosystem by open-sourcing missing building blocks like API clients. Links: Hindley–Milner type system Standard ML OCaml ReScript ReasonML / Reason Tarides X/Twitter: @sabine_s_ GitHub: @Sabine Bluesky: @sabine.sh Dream (OCaml web framework) SolidJS MLX (.mlx / JSX for OCaml) TyXML Opam FUN OCaml ICFP (International Conference on Functional Programming) OCaml Workshop 2025 Semgrep Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.
#58
Dec 16, 2025 · 43 min
Deferred Conflict (with Steve Klabnik)
Jared interviews Steve Klabnik (Rust author and longtime OSS contributor) about JJ (Jujutsu), a newer version control system that can operate on Git repos via pluggable backends so you can adopt it locally without forcing teammates to switch, while getting a simpler, more flexible workflow. Steve explains JJ’s core shift: no staging/index—your working copy is effectively a mutable commit you shape as you work, making it easier to split, squash, and rewrite history without juggling Git’s extra layers and flags, and even “stash” becomes just more visible commits. He highlights JJ’s stable change IDs (so you can refer to work even as hashes change), its conflict model where rebases complete immediately and mark conflicted commits for later resolution (great for many parallel branches), and features like jj absorb (auto-placing review fixes into the right earlier commits) and jj undo (a full operation history that makes experimentation feel safe). Steve also teases work on a JJ-native collaboration/review product inspired by Gerrit-style patch workflows. Links: Jujutsu (jj) on GitHub Jujutsu docs Steve’s Jujutsu tutorial “I see a future in jj” (Steve Klabnik) East River Source Control (ERSC) jj CLI reference jj absorb jj undo Working with Gerrit (jj docs) Git commit “trailers” / metadata Git hooks Git LFS Perforce Helix Core Sapling SCM Mercurial GitButler The Rust Programming Language (“The Book”) Steve Klabnik’s site why the lucky stiff (Wikipedia) Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.

Showing 1–20 of 25 episodes