Dead Code

In this episode of Dead Code, Jared talks with Alan Ridlehoover, Senior Engineering Manager at Cisco Meraki, about managing software complexity through clear abstractions and thoughtful design. Using a metaphor of a vending-style coffee machine, Alan explains how complexity often arises not from algorithms but from code that’s hard to understand due to excessive abstraction or poor structure. He emphasizes focusing on the readability of what’s directly in front of you, using tools like flog and the ABC metric to quantify complexity, while also trusting gut instinct and applying heuristics like Sandi Metz’s five-line rule. Alan discusses minimizing over-engineering, favoring well-named private methods over inline comments, and stresses that code and commit messages—not comments—should tell the story. He also introduces “rehydration,” the process of adding back duplication to reveal better abstractions, helping developers make their code more maintainable and easier to change over time.Links:Flog (Ruby)ABC MetricGerritDRY Principle (Don’t Repeat Yourself)Domain-Driven Design (DDD)PolymorphismDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared chats with Scott Werner, CEO of Sublayer, about his experimental AI web framework, Monkey’s Paw—a Ruby-based tool that uses natural language prompts to generate web pages, embracing LLM “hallucinations” as a creative feature rather than a flaw. Designed to bring back the playful spirit of early Web 2.0, Monkey’s Paw allows developers to prototype ideas quickly and unexpectedly, often resulting in delightful, unintended features like auto-generated tooltips. Scott explains how the project reflects a broader shift toward ephemeral, AI-assisted development and introduces Sublayer, his minimal agent framework built for AI generation. Both Jared and Scott agree that while LLMs may not produce enduring art, they offer fun, whimsy, and new ways to experiment in coding, highlighting how these tools can be valuable outside of pure productivity or profit-driven goals.Links:Monkey’s PawSublayerArtificial RubyWorks on My Machine (Substack)WebsimTRICK CompetitionRails GeneratorsPowerPoint CopilotDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

Short-Form Summary:In this episode of Dead Code, host Jared chats with Noel Rappin, Staff Engineer at Chime and co-author of the updated Programming Ruby (“The Pickaxe Book”), about revitalizing Ruby’s most iconic reference. Rappin explains that despite claims Ruby is “dead,” it’s still widely used by startups and major companies like GitHub and Shopify. He took on the update to bridge the gap between Ruby 2.0 and 3.3, modernizing the book to reflect new features like pattern matching and changes in the ecosystem, while keeping it relevant for today’s developers, many of whom are coming from JavaScript, Python, or Java. They discuss the balance between Ruby’s flexible syntax and emerging norms via tools like RuboCop, the cautious use of metaprogramming, and how Ruby’s expressive power still stands out. Rappin hints at a future Ruby 4 update and encourages developers to embrace Ruby’s strengths, especially for teams valuing agility and clarity.Links:Noel RappinDave ThomasProgramming Ruby (The Pickaxe Book)why’s (poignant) Guide to RubyBundlerRuboCopStandardRBRactorsPattern Matching in RubySorbetRBSSteep Dry-typesSinatraRSpecConcurrent RubyFibersDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared is joined by Lucian and returning guest Joel to debate a classic Ruby dilemma: whether to access instance variables directly or use getter methods. Lucian advocates for getters, especially in large, fast-changing codebases, arguing they help catch subtle bugs and improve maintainability, as well as insights drawn from his time at Cookpad and the Short Ruby newsletter. Joel, while appreciating the clarity and performance of direct access, introduces his gem strict_ivars, which raises runtime errors for undefined variables, offering a hybrid solution that improves safety without sacrificing flexibility. The conversation expands into the future of Ruby developer experience, discussing AST-based tooling, the role of testing, and how small, intentional coding choices can add up to more resilient and readable software.Links:Short Ruby NewsletterShow Ruby YouTube ChannelJoel Draper’s Websitestrict_ivars GemJoel on BlueskyPractical Object-Oriented Design in Ruby (POODR) by Sandi MetzPrism Bootsnapruby-require-hooks by Vladimir DementyevAST (Abstract Syntax Tree)Modified Condition/Decision Coverage (MCDC) – advanced testing techniqueRuby Keyword ArgumentsCookpadPlaneShopifyDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared interviews Heydon Pickering about his satirical strategy to sabotage AI web crawlers by generating nonsense versions of his blog posts. Using Eleventy and JS DOM, Heydon replaces keywords in his content with absurd alternatives from a static lexicon, creating grammatically broken, jargon-filled text that wastes crawler resources without harming his SEO. Frustrated by how LLMs scrape web content without consent, he frames his approach as both a protest and a creative, Dadaist rebellion against exploitative tech norms. While the method won’t cripple AI models, it reflects a broader resistance to the unchecked harvesting of human-created content.Links:“Poisoning the Well” (Heydon’s article)“Please Stop Externalizing Your Costs Directly In My Face” – The article that partly inspired Heydon’s efforts to push back against LLM scraping.Heydon’s BlogWebbed Briefs (Heydon’s video series)Eleventy (11ty)JS DOMrobots.txtnofollow attributeDadaismDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared talks with Stevan about building reliable distributed systems using Erlang-inspired design patterns. Stevan shares how his background in functional programming and formal verification led him to simulation testing—a deterministic approach to testing distributed systems that avoids the flakiness of traditional CI environments. He emphasizes that Erlang’s true innovation lies not in lightweight processes, but in its structured behaviors (like gen_server and supervisor), which make systems easier to reason about, test, and verify. These behaviors support a more disciplined approach to concurrency, enabling reproducible fault injection and better simulation frameworks. Stevan advocates for programming languages that natively support deterministic testing and model checking, suggesting that the future of distributed systems lies in building on these structured, verifiable foundations.Links:Stevan’s BlogErlangElixirAgdaIdrisTLA+RocJepsenAntithesisBEAMLet it crash philosophyDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared interviews Carson Gross, creator of HTMX, about the principle of Locality of Behavior (LoB) and its role in web development. Carson explains that HTMX enhances HTML rather than replacing it like modern JavaScript frameworks, offering a simpler, hypermedia-driven approach ideal for use cases like e-commerce. He critiques the traditional emphasis on Separation of Concerns, arguing that keeping behavior close to markup improves maintainability and avoids “spooky action at a distance.” Carson acknowledges trade-offs between LoB, DRY, and SoC, emphasizing the importance of context-based decision-making. He and Jared also discuss broader software trends, advocating for deeper modules, simpler APIs, and a pragmatic, less ideological approach to coding as the industry evolves.Links:HTMX WebsiteHTMX Essays (especially Locality of Behavior and When to Use Hypermedia)grugbrain.devHypermedia Systems BookRichard Gabriel’s “Worse Is Better” EssayMozilla Developer Network (MDN)John Ousterhout’s A Philosophy of Software DesignThe Uncle Bob vs. John Ousterhout ArgumentBig Sky Software (Carson’s Company)HyperscriptDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared chats with Nora, a Rust contributor, about operator precedence and the trade-offs between code clarity and conciseness across programming languages. Nora, inspired by her blog post “Don’t Play the Precedence Game,” explains how languages like C and Rust handle operator order differently, particularly around equality and bitwise operations, which can lead to subtle, hard-to-spot bugs. She advocates for using parentheses generously to make intent explicit, even if some consider it “noisy,” and highlights how tools like linters and formatters approach optional syntax differently. They also touch on Ruby’s permissive style, Lisp’s avoidance of precedence via prefix notation, and broader lessons for language design—ultimately agreeing that clarity should win when it matters, and that different languages cater to different developer mindsets.Links:“Don’t Play the Precedence Game” RustC Programming LanguageRubyLispGoRescriptrustfmtClippyPrettierNora’s Website  Nora’s MastodonNora’s GitHub Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

In this episode of Dead Code, Jared speaks with software engineer Nicole Tietz-Sokolskaya about the ethical complexities of large language models (LLMs). Nicole shares her mixed experiences with LLMs—finding brief personal value but little long-term usefulness in her work—and critiques their environmental impact, reliance on questionable training data, and potential to concentrate power among major tech companies. She raises concerns about consent, bias, and the quality of generated code, while also acknowledging LLMs’ potential in accessibility and trust and safety roles. Ultimately, both Nicole and Jared advocate for a values-driven approach to technology, urging developers to critically evaluate the tools they use and the broader implications of their choices.Links:Mastodon: nicole@tietz.socialNicole’s BandcampCan I Ethically Use LLMs?Talon Voice SoftwareRecurse CenterDeconstruct ConfAMP ProjectDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript