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.
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.
09/03/24 • 36 min
In this episode of "Dead Code," Jared and Harmony, a self-taught programmer with extensive experience in Ruby, explore the benefits of experimenting with unconventional programming languages. They discuss Fennel, a Lisp that compiles to Lua, highlighting its simplicity and versatility for applications like game modding. Jared shares his experience with ReScript, a language in the ML family that compiles to JavaScript, emphasizing its strong type system and seamless integration with React. They also delve into Uiua, a stack-based array language with a unique symbol-rich syntax, which Harmony finds ideal for tackling complex mathematical programming challenges. The episode emphasizes how these esoteric languages can broaden a programmer's perspective and problem-solving approach.
Links:
Conway’s Game of Life Interactive Simulator
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
Frozen to Death (with Kevlin Henney)
Dead Code
04/01/25 • 54 min
In this episode of Dead Code, Jared talks with Kevlin Henney about the importance of immutability in software development, particularly as a strategy for reducing bugs related to state and concurrency. Kevlin explains that while many programming languages default to mutable state, treating state change as a privilege—not a right—can lead to more maintainable, less error-prone code. He discusses how immutability strengthens encapsulation, simplifies reasoning about systems, and avoids issues like race conditions and deadlocks, especially in multi-threaded environments. Kevlin also emphasizes that these design choices are architectural, not just implementation details, and that teams benefit from shared philosophies around state management. The conversation ties into broader programming culture and offers practical insights for developers, especially those working in languages like Ruby, where mutability is common but evolving.
Links:
Kevlin Henney’s article – “Restrict Mutability of State”
Book – 97 Things Every Programmer Should Know
Open source repo with contributions
Overflow collection curated by Shirish Padalkar (includes the “Restrict Mutability of State” essay)
RubyConf Mini Providence Talk – Immutable Data Structures
RailsConf Talk – Immutable Objects in Practice
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
01/14/25 • 29 min
In this episode of Dead Code, Jared Norman interviews Felienne Hermans, creator of the Hedy programming language and author of “A Case for Feminism in Programming Language Design.” Felienne discusses her experiences of alienation in the programming language design community and critiques its prioritization of mathematical rigor and technical difficulty over accessibility and inclusivity. Highlighting Hedy, a simplified, multilingual language designed for beginners and non-English speakers, she emphasizes the value of user-centered design in making programming more approachable and impactful. The conversation explores the exclusionary culture in programming, such as dismissing spreadsheets and front-end work as “not real coding,” and proposes reimagining programming languages to focus on collaboration, user experience, and joy rather than gatekeeping and status. Felienne calls for a cultural shift to prioritize inclusivity and creativity, showcasing how tools like Hedy can inspire and empower diverse communities.
Links:
A Case for Feminism in Programming Language Design
Felienne Hermans’s Personal Website
Programming Language Conference: SPLASH
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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.
Show more best episodes
Show more best episodes
FAQ
How many episodes does Dead Code have?
Dead Code currently has 39 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