Dead Code

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.

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.

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.

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.

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.