Dead Code
Jared Norman
Hosted on Acast. See acast.com/privacy for more information.
All episodes
Best episodes
Top 10 Dead Code Episodes
Goodpods has curated a list of the 10 best Dead Code episodes, ranked by the number of listens and likes each episode have garnered from our listeners. If you are listening to Dead Code for the first time, there's no better place to start than with one of these standout episodes. If you are a fan of the show, vote for your favorite Dead Code episode by adding your comments to the episode page.
04/22/25 • 28 min
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”
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
10/15/24 • 30 min
In this episode, Jared speaks with Coraline Ada Ehmke, a veteran software developer and creator of the Contributor Covenant and Hippocratic License, about the ethics of open-source software. Coraline discusses common justifications developers use to avoid accountability for the potential harm their software may cause, such as the "freedom zero" argument advocating for unrestricted use of software and the belief that access to the source code ensures ethical behavior. She critiques these views, emphasizing that developers must consider the societal impact of their work and set clear ethical boundaries. Coraline encourages the use of a "negative roadmap" to define what developers refuse to build, urging them to think critically about the harm their technology may enable. The episode concludes with Coraline promoting her work with the Organization for Ethical Source and her upcoming book, which explores responsible tech practices.
Links:
Organization for Ethical Source
United Nations Universal Declaration of Human Rights
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
10/01/24 • 46 min
In this episode of Dead Code, J.B. Rainsberger discusses the pitfalls of integrated tests, calling them a "scam" due to their tendency to complicate rather than solve testing problems. He advocates for writing smaller, more focused tests, like unit tests, to simplify debugging and avoid tangled code. J.B. emphasizes that test-driven development (TDD) should be flexible, guiding developers to test based on what they're afraid might break, rather than following rigid rules. He introduces the concept of four stages of TDD, where developers evolve from focusing on bug prevention to refining their approach based on experience, adapting their testing strategy to different contexts while maintaining the core principle of starting with a failing test.
Links:
J.B.'s technical blog: The Code Whisperer
J.B.'s broader development blog: Blog by JBrains
Matteo Vaccari’s article: How I Learned to Love Mock Objects
Growing Object-Oriented Software, Guided by Tests by Steve Freeman and Nat Pryce
Test-Driven Development: By Example by Kent Beck
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
03/11/25 • 26 min
In this episode of Dead Code, Jared interviews James Gayfer about data modeling and the challenges of structuring databases effectively. James, who prefers raw SQL over ORMs, explains how many database models merely mirror table structures, leading to inefficient APIs and excessive data fetching. He discusses the concept of complete versus incomplete data models, emphasizing that completeness depends on an application’s needs at a given time. They explore trade-offs between overly simplistic models that require frequent queries and overly complex ones that attempt to replicate real-world relationships in unnecessary detail. James advocates for designing domain models thoughtfully, using patterns like repositories to maintain consistency while keeping data retrieval manageable. Ultimately, he encourages developers to embrace iteration, rethink their models as needed, and accept that all models are wrong, but some are useful.
Links:
James Gayfer’s Mastodon profile
All models are wrong, but some are useful
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
11/19/24 • 30 min
In this Dead Code episode, Jared Norman hosts Aji Slater, Development Team Lead at thoughtbot, to discuss “incremental automation,” a concept that advocates for gradually automating tasks by refining them with small steps rather than investing large amounts of time upfront. Aji explains that capturing each step of repetitive tasks enables developers to tweak processes over time, which reduces friction and saves effort without disrupting workflows. Starting with “do-nothing scripts” that print steps or copy commands, developers can progressively automate, building efficiencies that enhance productivity and prevent burnout. Aji also emphasizes sharing these incremental improvements across teams, so everyone benefits from the refined workflows without repeating the same manual work.
Links:
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
01/07/25 • 41 min
In this Dead Code episode, host Jared Norman interviews JP Camara, Principal Software Engineer at Wealthbox, about Ruby concurrency. JP explains that Ruby applications are inherently multithreaded, even when developers assume otherwise, highlighting how background threads from libraries like Sidekiq or monitoring tools can introduce concurrency issues. He discusses the Ruby community's progress in thread safety, driven by tools like Puma and Sidekiq, and contrasts Ruby's "colorless" concurrency model with JavaScript's explicit async/await syntax, emphasizing Ruby's reduced cognitive overhead. JP also shares his experience contributing to Ruby's M:N thread scheduler for macOS, advocating for developers to rely on vetted concurrency tools like concurrent-ruby and async instead of manually managing threads. He concludes by stressing the importance of avoiding global state, breaking tasks into smaller pieces, and approaching concurrency with a thoughtful mindset.
Links:
Meshuggah – Violent Sleep of Reason
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
03/18/25 • 33 min
In this episode of Dead Code, host Jared Norman speaks with Jean Boussier, a key contributor to the Ruby community and Shopify engineer, about the challenges of concurrency in Ruby, particularly the Global VM Lock (GVL). Jean explains that while the GVL was originally implemented to simplify Ruby’s design, it now limits parallel execution, sparking debate on whether it should be removed. He argues that many Ruby applications are more CPU-bound than previously thought and suggests improving Ruby’s thread scheduler as a more practical short-term solution rather than eliminating the GVL entirely. The discussion also explores Ractors, Ruby’s experimental approach to parallelism, which remains unstable and impractical for most applications. Jean envisions a future where Ractors become more viable, gradually leading to broader concurrency improvements. The episode wraps up with insights on profiling tools and the evolving landscape of Ruby performance optimization.
Links:
Ivo Anjo’s GVL Profiling Talk (RubyConf)
Jean’s Blog Post: “So, You Want to Remove the GVL?”
Jean’s Blog Post: “The Mythical IO-Bound Rails App”
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
05/20/25 • 43 min
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:
Practical Object-Oriented Design in Ruby (POODR) by Sandi Metz
ruby-require-hooks by Vladimir Dementyev
Modified Condition/Decision Coverage (MCDC) – advanced testing technique
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
04/29/25 • 45 min
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 Essays (especially Locality of Behavior and When to Use Hypermedia)
Richard Gabriel’s “Worse Is Better” Essay
Mozilla Developer Network (MDN)
John Ousterhout’s A Philosophy of Software Design
The Uncle Bob vs. John Ousterhout Argument
Big Sky Software (Carson’s Company)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
05/13/25 • 37 min
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.
Webbed Briefs (Heydon’s video series)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
Show more best episodes
Show more best episodes
FAQ
How many episodes does Dead Code have?
Dead Code currently has 44 episodes available.
What topics does Dead Code cover?
The podcast is about Computer Science, Software, Software Development, Podcasts, Technology and Programming.
What is the most popular episode on Dead Code?
The episode title 'Supplemental Oxygen (with Senem Soy and Alistair Norman)' is the most popular.
What is the average episode length on Dead Code?
The average episode length on Dead Code is 37 minutes.
How often are episodes of Dead Code released?
Episodes of Dead Code are typically released every 7 days.
When was the first episode of Dead Code?
The first episode of Dead Code was released on Mar 12, 2024.
Show more FAQ
Show more FAQ