Dead Code

Hosted by Jared Norman

TechnologyInterviews guests

Website RSS feed

Episodes

Latest episode

Jun 2026

Language

About the show

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.

Listen to episodes

60 recent

June 9, 202627 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 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 Hosted on Acast. See acast.com/privacy for more information.

April 21, 202639 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 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 Hosted on Acast. See acast.com/privacy for more information.

April 7, 202619 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 platformCSS nesting:has() selectorCSS variables (custom properties)CSS animationsCSS container queriesCookie Clicker (incremental game example)x86 architecture overview8086 CPUC programming languageContent Security Policy (CSP)Cross-site scripting (XSS)SVG filtersDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

March 24, 202639 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 CraftsmanDave CopelandBrut Ruby Web FrameworkRuby Programming LanguageRuby on RailsSoftware Craftsmanship MovementSOLID PrinciplesDependency InjectionCross-Site Request Forgery (CSRF)Agile Software DevelopmentObservability in Software SystemsLarge Language Models (LLMs)Accidental Tech PodcastDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

March 10, 202627 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:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

February 24, 202634 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 catalogRuss Olsen’s blog: “Technology As If People Mattered”Russ Olsen (about page)Overdrive by Russ OlsenRBS (Ruby type signatures) on GitHubSorbet (Ruby type checker) docsRuby pattern matching documentationTruffleRuby documentation (GraalVM Ruby)Ruby Regexp documentationDead Code Episode: “Pickaxe Resurrection (with Noel Rappin)”Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

February 10, 202643 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.netficd.shDaniel’s blogLobstersThe XY ProblemMotherfucking WebsiteCrafting InterpretersCodebergDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

January 27, 202649 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.comWeb AwesomeFont AwesomeTailwind: Introducing CatalystCatalyst docsshadcn/uidaisyUITailwind docs: Functions & directivesMDN: :where() selectorMDN: Popover APIMDN: CSS anchor positioningMDN: <dialog> elementMDN: Invoker Commands APIMDN blog: Exclusive accordions with <details name>web.dev: Interop 2026 proposalsRuby on RailsSQLiteDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

January 13, 202646 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 CodeVimContinuous integration (Martin Fowler)Extreme Programming (XP)Pull requests (GitHub docs)KubernetesDockerLet’s EncryptMastodonDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.

December 30, 202538 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 systemStandard MLOCamlReScriptReasonML / ReasonTaridesX/Twitter: @sabine_s_GitHub: @SabineBluesky: @sabine.shDream (OCaml web framework)SolidJSMLX (.mlx / JSX for OCaml)TyXMLOpamFUN OCamlICFP (International Conference on Functional Programming)OCaml Workshop 2025SemgrepDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript Hosted on Acast. See acast.com/privacy for more information.