Dead Code

Jared’s Links:

Sean Goedecke’s article: “You can’t design software you don’t work on”

Hosted on Acast. See acast.com/privacy for more information.

Frankenstein’s System (with Sean Goedecke)

Tue, 10 Mar 2026 13:00:00 GMT

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:

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:

Jared’s Links:

Eloquent Ruby, Second Edition (beta/book page)

Hosted on Acast. See acast.com/privacy for more information.

Indistinguishable From Evil (with Russ Olsen)

Tue, 24 Feb 2026 14:00:00 GMT

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:

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:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

The Slop Slope (with Daniel Fichtinger)

Tue, 10 Feb 2026 14:00:00 GMT

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:

Dead Code Podcast Links:

Jared’s Links:

Tailwind: Introducing Catalyst

Hosted on Acast. See acast.com/privacy for more information.

Zero Specificity (with Stephen Margheim)

Tue, 27 Jan 2026 14:00:00 GMT

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

Catalyst docs

shadcn/ui

daisyUI

Tailwind docs: Functions & directives

MDN: :where() selector

MDN: Popover API

MDN: CSS anchor positioning

MDN:

IDE-cide (with Samir Talwar)

Tue, 13 Jan 2026 14:00:00 GMT

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)

Dead Code Podcast Links:

Jared’s Links:

Hindley–Milner type system

Hosted on Acast. See acast.com/privacy for more information.

Death From Algorithm W 1978 (with Sabine Schmaltz)

Tue, 30 Dec 2025 14:00:00 GMT

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:

X/Twitter: @sabine_s_

GitHub: @Sabine

Bluesky: @sabine.sh

Dream (OCaml web framework)

SolidJS

MLX (.mlx / JSX for OCaml)

TyXML

Opam

FUN OCaml

ICFP (International Conference on Functional Programming)

OCaml Workshop 2025

Semgrep

Dead Code Podcast Links:

Jared’s Links:

“I see a future in jj” (Steve Klabnik)

Hosted on Acast. See acast.com/privacy for more information.

Deferred Conflict (with Steve Klabnik)

Tue, 16 Dec 2025 14:00:00 GMT

Jared interviews Steve Klabnik (Rust author and longtime OSS contributor) about JJ (Jujutsu), a newer version control system that can operate on Git repos via pluggable backends so you can adopt it locally without forcing teammates to switch, while getting a simpler, more flexible workflow. Steve explains JJ’s core shift: no staging/index—your working copy is effectively a mutable commit you shape as you work, making it easier to split, squash, and rewrite history without juggling Git’s extra layers and flags, and even “stash” becomes just more visible commits. He highlights JJ’s stable change IDs (so you can refer to work even as hashes change), its conflict model where rebases complete immediately and mark conflicted commits for later resolution (great for many parallel branches), and features like jj absorb (auto-placing review fixes into the right earlier commits) and jj undo (a full operation history that makes experimentation feel safe). Steve also teases work on a JJ-native collaboration/review product inspired by Gerrit-style patch workflows.

Links:

Jujutsu (jj) on GitHub

Jujutsu docs

Steve’s Jujutsu tutorial

East River Source Control (ERSC)

jj CLI reference

jj absorb

jj undo

Working with Gerrit (jj docs)

Git commit “trailers” / metadata

The Rust Programming Language (“The Book”)

Steve Klabnik’s site

why the lucky stiff (Wikipedia)

Dead Code Podcast Links:

Jared’s Links:

ViewComponent GitHub Repo

Hosted on Acast. See acast.com/privacy for more information.

Poison Pills (with Joel Hawksley)

Tue, 02 Dec 2025 14:00:00 GMT

In this episode, GitHub engineer Joel Hawksley breaks down the evolution of GitHub’s UI architecture—from Rails views to ViewComponent to React—and the tradeoffs behind each step. ViewComponent emerged as a practical, backwards-compatible way to eliminate duplicated UI logic in GitHub’s massive Rails monolith, ultimately supporting thousands of components and becoming a key driver of consistency and accessibility. Joel explains how hard UI correctness is compared to backend systems, how keyboard-only tests surfaced real accessibility regressions, and why ViewComponent v4 streamlines the project as it enters a stable, long-term support phase. He also discusses why GitHub increasingly leans on React for complex, app-like behavior: developer enthusiasm, design-system tooling, CSS encapsulation, and the need to manage frontend–backend sync at scale. The conversation closes with reflections on the realities of open-source maintenance and the importance of stability as ViewComponent’s future.

Links:

Joel Hawksley’s Website

ViewComponent Website

Primer ViewComponents

Primer ViewComponents Repo

Phlex Website

Phlex GitHub Repo

Herb GitHub Repo

ReActionView GitHub Repo

WCAG Accessibility Standards

Rails Strict Locals Documentation

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Ground Zero-Cost Bindings (with Josh Vlk)

Tue, 18 Nov 2025 14:00:00 GMT

In this Dead Code episode, Jared and ReScript contributor Josh Vlk explain why ReScript is a strongly typed, sound language for web development that compiles to JavaScript, offers first-class React support, and favors a “one right way” approach (built-in formatter, no linters) over TypeScript’s configurable sprawl. They trace its evolution from Reason/BuckleScript to today’s standalone ReScript, with v12 shedding legacy OCaml baggage, adding a rewritten Rust compiler for major speed, native monorepo support, zero-cost JS bindings, and automated upgrade fixes. The pair highlight how variant types and exhaustive pattern matching naturally model complex business logic and make refactors safe and fast, often resulting in less code and fewer bugs. Adoption can be incremental—drop a rescript.json, compile alongside TS/JS, and start with a small component or state reducer. Jared closes by urging developers to try it, noting ReScript’s consistency may also make it especially friendly for AI-assisted coding.

Links:

“ReScript Has Come a Long Way — Maybe It’s Time to Switch from TypeScript” by Josh Vlk

“Domain Driven Design Made Functional” by Scott Wlaschin (F# / functional programming concepts)

ReScript Forums

ReScript Docs

ReScript Packages on npm – Community bindings and libraries

Josh Vlk on Bluesky

Josh’s website

Dead Code Podcast Links:

Jared’s Links:

Content Security Policy (CSP)

Hosted on Acast. See acast.com/privacy for more information.

Brut-al Death (with David Bryant Copeland)

Tue, 04 Nov 2025 14:00:00 GMT

In this episode, Dave Copeland discusses Brut, his Ruby web framework built atop Sinatra that prioritizes “simple over easy” design principles. Brut replaces traditional MVC with pages, forms, and handlers, uses Flex for HTML generation, Sequel for database access, and lightweight tools like BrutCSS and BrutJS for styling and interactivity, emphasizing direct alignment with web standards. It eliminates free-form parameter hashes by injecting structured objects, mirrors HTML for form validations, and defaults to a strict, Postgres-only setup with non-nullable fields, required foreign keys, and built-in observability through OpenTelemetry and a strict Content Security Policy. Dave and Jared also discuss modern browser-based CSRF protections, the philosophy behind Brut’s defaults, and how Dave aims to refine it toward a 1.0 release with real-world apps and clear migration paths for Rails developers, positioning Brut as a lightweight, standards-aligned alternative within the Ruby ecosystem.

Links:

Rich Hickey – “Simple Made Easy” talk

Burg.rb

Dead Code Podcast Links:

Jared’s Links:

Your Code as a Crime Scene

Hosted on Acast. See acast.com/privacy for more information.

God Class Funeral (with Adam Tornhill)

Tue, 21 Oct 2025 13:00:00 GMT

Jared talks with Adam Tornhill, founder of CodeScene, about the psychology of programming and how understanding human cognitive limits leads to better software. Adam explains that since working memory can only juggle a few items at once, developers must rely on chunking and good abstractions to manage complexity. His Code Health metric, based on detecting “ugliness” like long functions and low cohesion, shows that healthy code enables teams to deliver features up to ten times faster with far fewer defects. They discuss how God classes become coordination bottlenecks, how behavioral code analysis reveals hotspots where improvement matters most, and why learning different programming paradigms sharpens thinking. Adam emphasizes that writing readable, well-named, modular code benefits both humans and AI tools—because clarity, consistency, and thoughtful naming make code easier to understand, maintain, and extend.

Links:

CodeScene

Working Memory

God Class / God Object

Domain-Specific Languages (DSLs)

Dead Code Podcast Links:

Jared’s Links:

Ruby Marshal documentation

Hosted on Acast. See acast.com/privacy for more information.

Deserial Killer (with Matt Schwager)

Tue, 07 Oct 2025 13:00:00 GMT

Jared sits down with Trail of Bits security engineer Matt Schwager to discuss the persistent security risks of Ruby’s Marshal library. Matt explains that while Marshal (and Python’s Pickle) makes serialization simple and fast for tasks like caching, its “serialize anything” design has led to over a decade of recurring vulnerabilities. Despite repeated patches, new bugs and exploitation gadgets keep surfacing, often hidden in defaults or legacy code, as seen in Rails caching and RubyGems.org. Matt argues that this reflects a fundamental trade-off between ergonomics and security, suggesting alternatives like JSON are safer, though less convenient. He highlights mitigation strategies such as documentation, static analysis, and fuzzing with his tool Ruzzy, while also pointing to broader Ruby risks like eval misuse, SSRF, and supply chain issues. Jared reflects on the cultural tension in Ruby between ease of use and security, wondering if safer defaults could help developers avoid these common pitfalls.

Links:

Trail of Bits Blog

Python Pickle documentation

RubyGems source on GitHub

Ruzzy on GitHub

AFL on GitHub

Semgrep Registry

Black Hat USA 2017 Talk

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Crushing Riffs (with Kasper Timm Hansen)

Tue, 23 Sep 2025 13:00:00 GMT

In this Dead Code episode, Jared talks with longtime Rubyist and former Rails Core member Kasper Timm Hansen about “riffing,” a sketch-first approach to software design. Instead of jumping straight into migrations and production code, Kasper opens a scratch Ruby file—mixing real and pseudo-code with short prompts—to explore names, relationships, and system flow without worrying about correctness. The practice surfaces unknowns early, conserves mental stamina, and produces lightweight artifacts that can guide teams or even become executable prototypes. Kasper shares stories from client work, a RailsConf demo, and workshops showing how riffing helps uncover design flaws, generate stronger options, and make domain modeling more collaborative. He encourages developers to treat code like sketches, be less precious about early ideas, and embrace riffing as a fun, low-cost way to boost creativity and resilience in software design.

Links:

Spinel Coop

RailsConf 2024 Talk (YouTube)

RailsConf 2024 Slides (Speaker Deck)

Kasper’s website

Kasper’s GitHub

Dead Code Podcast Links:

Jared’s Links:

Growing Object-Oriented Software, Guided by Tests by Steve Freeman & Nat Pryce

Hosted on Acast. See acast.com/privacy for more information.

Fear-Driven Everything (with Justin Searls)

Tue, 09 Sep 2025 13:00:00 GMT

On this episode of Dead Code, Jared talks with Justin Searls, co-founder of Test Double, about programming workflows, decision-making, and the evolving role of developers. They explore how the order and tempo of thought matter more than static code, why tackling the riskiest problems first can shape better outcomes, and how Justin’s idea of the “full-breadth developer” expands a programmer’s role to include product vision and context. The conversation touches on Agile and XP roots, consulting realities, and how AI coding agents can both accelerate and complicate work. The episode wraps with Justin encouraging blogging and direct connection, while Jared reflects on building a “grand unified theory” of how programmers decide their next step.

Links:

Test Double

Justin Searls: Find his writing, projects, and podcast Breaking Change at justin.searls.co

Extreme Programming Explained by Kent Beck

The Secrets of Consulting by Jerry Weinberg

Dead Code Podcast Links:

Jared’s Links:

“CEOs Are Publicly Boasting About Reducing Their Workforces With AI” – Futurism

Hosted on Acast. See acast.com/privacy for more information.

Rage Quit Stamina Theory

Tue, 26 Aug 2025 13:00:00 GMT

The 50th episode of the Dead Code Podcast brought Karl Weber, Jared Norman, Benjamin Wil, Sofia Besenski, and Noah Silveira together to mark the milestone with sharp, funny, and critical takes on the state of tech. They skewered CEOs bragging about AI-driven layoffs as short-sighted profiteering, questioned the hype fueling the AI bubble, and praised Ruby and Rails for extending developers’ “rage quit stamina” despite flaws in error reporting and dependency management. The group emphasized the importance of empathetic, fast code reviews and smaller PRs, arguing that culture and collaboration matter more than mythical “10x developers.” They also critiqued DHH’s claim that executives should be the least busy, framing it as privilege disguised as wisdom, while pointing out that rest and balance benefit everyone. The episode captured their signature mix of humor, industry critique, and camaraderie, closing with gratitude for 50 episodes and excitement for what’s next.

Links:

Giveaway: Anarchy Agile hats — enter at jardo.dev/anarchyagile

The Pragmatic Engineer 2025 Survey: What’s in your tech stack? Part 1

“Two Simple Rules to Fix Code Reviews” – The Pragmatic Engineer

“In Praise of Normal Engineers” – Charity Majors, Honeycomb

“Executives Should Be the Least Busy People” – David Heinemeier Hansson

Dead Code Podcast Links:

Jared’s Links:

Why’s (Poignant) Guide to Ruby

Hosted on Acast. See acast.com/privacy for more information.

Radiation Hardened (with Dave Gauer)

Tue, 12 Aug 2025 13:00:00 GMT

In this episode of Dead Code, Jared interviews Dave Gauer, creator of the Ziglings project—a whimsical, hands-on tutorial for learning the Zig programming language. Dave shares how Ziglings began as a personal learning tool and grew into a widely loved resource, especially among younger developers. He emphasizes the value of learning in public, blending humor, accessibility, and bite-sized challenges to make complex systems programming concepts less intimidating. The conversation also explores Dave’s deep interest in the Forth language, the appeal of small, self-contained “microworlds” for learning, and his broader philosophy on sharing work, embracing whimsy, and building things that make programming joyful and approachable.

Links:

Learning Perl

The Little Schemer

Mindstorms by Seymour Papert

Steal Like an Artist by Austin Kleon

Ratfactor.com – Dave Gauer’s personal website and blog.

Forth in Space (section on Ratfactor) – Dave’s notes on how Forth has been used in radiation-hardened chips and space tech.

Dead Code Podcast Links:

Jared’s Links:

Legibility (as a concept)

Hosted on Acast. See acast.com/privacy for more information.

Epistemic Extinction (with Mond)

Tue, 29 Jul 2025 13:00:00 GMT

In this episode of Dead Code, Jared and guest Mond explore how James C. Scott’s concepts of legibility, metis, and episteme apply to tech interviews, arguing that standardized hiring processes prioritize what’s easy to measure over what truly reflects engineering skill. They critique the over-reliance on algorithmic interviews, noting that senior engineering work often depends on tacit knowledge—metis—that can’t be captured in rubrics or LeetCode problems. The conversation touches on Goodhart’s Law, the risks of over-optimization, and how attempts to make human processes more legible through metrics can backfire. Jared shares how his company experiments with more realistic code assessments, though both acknowledge the challenges of scaling less standardized approaches. They conclude by warning that technological standardization of social systems, like hiring, can entrench flawed norms and obscure what actually matters.

Links:

James C. Scott

Seeing Like a State

Mond’s Blog – Here Comes the Moon

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Naked and Semantic (with Fabien Basmaison and Jens Oliver Meiert)

Tue, 15 Jul 2025 13:00:00 GMT

In this episode of Dead Code, Jared speaks with Jens Oliver Meiert and Fabien Basmaison, co-maintainers of CSS Naked Day, a long-standing web tradition that invites developers to strip CSS from their websites for one day to emphasize semantic HTML, accessibility, and the separation of concerns in front-end development. Originally launched in 2006, the event encourages developers to reflect on the underlying structure of their sites and how well they function without styling. Meiert and Basmaison discuss how modern tools like Tailwind, CSS-in-JS, and component-based design both challenge and occasionally align with the event’s philosophy, and they explore reasons for the decline in participation, from increased reliance on frameworks to the rise of AI-assisted development. Looking ahead to the 20th anniversary in 2026, they hope to inspire more developers to join in, even in small ways, as a reminder of the enduring value of accessible, maintainable, and standards-based web design.

Links:

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Eat Your Greens (with Ivo Anjo)

Tue, 01 Jul 2025 13:00:00 GMT

In this episode of Dead Code, Jared interviews Ivo Anjo, a Ruby performance expert at Datadog, about Ruby’s concurrency model and his work improving visibility into it. They discuss the Global VM Lock (GVL), which simplifies Ruby’s internals but hinders multithreading, and explore the promise and current limitations of M:N scheduling, now partially implemented via Ractors in Ruby 3.4. Ivo created the gvl-tracing gem to visualize thread behavior and uncover subtle bugs, advocating for a more intelligent, OS-like scheduler to improve performance fairness. He also shares insights from building Datadog’s always-on production profiler and his direct-bind gem, which allows low-level access to Ruby internals when official APIs fall short. Overall, the episode highlights a growing movement of developers modernizing Ruby’s internals and pushing past its reputation for being slow.

Links:

Dead Code Podcast Links:

Jared’s Links:

Episode 10 with Kevin Newton on Prism

Hosted on Acast. See acast.com/privacy for more information.

Herbicide (with Marco Roth)

Tue, 17 Jun 2025 13:00:00 GMT

In this episode of Dead Code, Jared talks with Marco Roth about Herb, a new fault-tolerant parser for HTML and ERB designed to improve the developer experience in the Rails ecosystem. Unlike tools like Deface or Nokogiri, Herb doesn’t auto-correct or mask errors—it parses templates exactly as written, enabling better diagnostics, formatting, and linting for server-rendered views, especially in Hotwire, Turbo, and Stimulus contexts. Built in C for portability and speed, Herb can be used across Ruby, JavaScript, and browsers via WebAssembly. Marco created it after running into limitations with existing tooling while building the Stimulus LSP. Future plans include deeper integration with tools like Ruby LSP and possibly enabling LiveView-style reactive rendering in Rails. Developers can try it today via a VS Code extension or the interactive web playground.

Links:

Herb VS Code Extension

Episode 38 with Carson Gross on HTMX

Dead Code Podcast Links:

Jared’s Links:

DRY Principle (Don’t Repeat Yourself)

Hosted on Acast. See acast.com/privacy for more information.

Coffee Grindcore (with Alan Ridlehoover)

Tue, 10 Jun 2025 13:00:00 GMT

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 Metric

Gerrit

Domain-Driven Design (DDD)

Polymorphism

Dead Code Podcast Links:

Jared’s Links:

Works on My Machine (Substack)

Hosted on Acast. See acast.com/privacy for more information.

Wish Granted (with Scott Werner)

Tue, 03 Jun 2025 13:00:00 GMT

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 Paw

Sublayer

Artificial Ruby

Dead Code Podcast Links:

Jared’s Links:

Programming Ruby (The Pickaxe Book)

Hosted on Acast. See acast.com/privacy for more information.

Pickaxe Resurrection (with Noel Rappin)

Tue, 27 May 2025 13:00:00 GMT

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 Rappin

Dave Thomas

why’s (poignant) Guide to Ruby

Pattern Matching in Ruby

Dead Code Podcast Links:

Jared’s Links:

Show Ruby YouTube Channel

Hosted on Acast. See acast.com/privacy for more information.

Undefined and Unforgiven (with Joel Drapper and Lucian Ghinda)

Tue, 20 May 2025 13:00:00 GMT

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 Newsletter

Joel Draper’s Website

strict_ivars Gem

Joel on Bluesky

Practical Object-Oriented Design in Ruby (POODR) by Sandi Metz

Prism

Bootsnap

ruby-require-hooks by Vladimir Dementyev

AST (Abstract Syntax Tree)

Modified Condition/Decision Coverage (MCDC) – advanced testing technique

Ruby Keyword Arguments

Cookpad

Plane

Shopify

Dead Code Podcast Links:

Jared’s Links:

“Poisoning the Well” (Heydon’s article)

Hosted on Acast. See acast.com/privacy for more information.

Poisoning the Well (with Heydon Pickering)

Tue, 13 May 2025 13:00:00 GMT

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:

“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 Blog

Webbed Briefs (Heydon’s video series)

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Deterministic Simulation (with Stevan)

Tue, 06 May 2025 13:00:00 GMT

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:

Let it crash philosophy

Dead Code Podcast Links:

Jared’s Links:

Richard Gabriel’s “Worse Is Better” Essay

Hosted on Acast. See acast.com/privacy for more information.

Brutality of Behaviour (with Carson Gross)

Tue, 29 Apr 2025 13:00:00 GMT

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 Website

HTMX Essays (especially Locality of Behavior and When to Use Hypermedia)

grugbrain.dev

Hypermedia Systems Book

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)

Hyperscript

Dead Code Podcast Links:

Jared’s Links:

“Don’t Play the Precedence Game”

Hosted on Acast. See acast.com/privacy for more information.

GOTO Precedence Hell (with Noratrieb)

Tue, 22 Apr 2025 13:00:00 GMT

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:

Rust

C Programming Language

Dead Code Podcast Links:

Jared’s Links:

Can I Ethically Use LLMs?

Hosted on Acast. See acast.com/privacy for more information.

Cursed Return (with Nicole Tietz-Sokolskaya)

Tue, 15 Apr 2025 13:00:00 GMT

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.social

Nicole’s Bandcamp

Dead Code Podcast Links:

Jared’s Links:

Kevlin Henney’s article – “Restrict Mutability of State”

Hosted on Acast. See acast.com/privacy for more information.

Frozen to Death (with Kevlin Henney)

Tue, 01 Apr 2025 13:00:00 GMT

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:

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

@Kevlin on Bluesky

@Kevlin@mastodon.social

Kevlin Henney on LinkedIn

Dead Code Podcast Links:

Jared’s Links:

Joan Westenberg’s Website

Hosted on Acast. See acast.com/privacy for more information.

Pattern Imprisonment (with Joan Westenberg)

Tue, 25 Mar 2025 13:00:00 GMT

In this episode of Dead Code, journalist Joan Westenberg joins host Jared to explore the political and ethical consequences of our tech choices, advocating for decentralized, open-source platforms over corporate-controlled ecosystems like Google and Meta. Joan shares her path from tech journalism to founding The Index, a reader-supported publication free from ads and investor influence, driven by a DIY punk ethos inspired by bands like Fugazi. She critiques the monopolization of the internet, the erosion of data privacy (especially for EU users), and the complicity of tech giants in supporting authoritarian politics. Emphasizing the power of small, intentional decisions, Joan urges listeners to resist cynicism, adopt “pragmatic meliorism,” and choose tools and platforms that align with their values—even if it’s harder—because incremental change still matters.

Links:

The Index

Murena / /e/OS

Where Wizards Stay Up Late: The Origins of the Internet

Dead Code Podcast Links:

Jared’s Links:

Ivo Anjo’s GVL Profiling Talk (RubyConf)

Hosted on Acast. See acast.com/privacy for more information.

Ordinary Corrupt Memory Love (with Jean Boussier (byroot))

Tue, 18 Mar 2025 13:00:00 GMT

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:

Jean Boussier’s Blog

Jean’s GitHub

Ivo Anjo’s GVL Profiling Tool

Jean’s Blog Post: “So, You Want to Remove the GVL?”

Jean’s Blog Post: “The Mythical IO-Bound Rails App”

Ruby Ractors Documentation

Dead Code Podcast Links:

Jared’s Links:

James Gayfer’s Mastodon profile

Hosted on Acast. See acast.com/privacy for more information.

All Models Are Wrong (with James Gayfer)

Tue, 11 Mar 2025 13:00:00 GMT

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 Blog

SQLx library for Rust

All models are wrong, but some are useful

Dead Code Podcast Links:

Jared’s Links:

Seven-Day Roguelike Challenge (7DRL) on itch.io

Hosted on Acast. See acast.com/privacy for more information.

Permadeath (with Roguelike Radio)

Tue, 04 Mar 2025 14:00:00 GMT

In this episode of Dead Code, Jared explores the world of roguelike game development with guests Mark R. Johnson and Darren Grey from Roguelike Radio, discussing the history, appeal, and technical challenges of the genre. They dive into the upcoming Seven-Day Roguelike Challenge, where developers create a game in a week, emphasizing the importance of procedural generation, permadeath, and strategic mastery. The conversation covers how roguelikes have evolved from classic ASCII-based dungeon crawlers to modern iterations like FTL and The Binding of Isaac, attracting both players and programmers due to their complexity and emergent gameplay. Darren and Mark share advice for aspiring developers, urging them to keep their projects small and focused while embracing the creative possibilities of procedural content.

Links:

Roguelike Radio Podcast

Roguelike Dev Community on Reddit

Roguelikes Community on Reddit

Mark R. Johnson’s Game (Ultima Ratio Regum)

Mark R. Johnson’s Twitter (X)

Mark R. Johnson’s Bluesky

Darren Grey’s Bluesky

Dead Code Podcast Links:

Jared’s Links:

Tilt (Ruby template engine support)

Hosted on Acast. See acast.com/privacy for more information.

Lethal Dependency Injection (with Tim Riley)

Tue, 25 Feb 2025 14:00:00 GMT

In this episode of Dead Code, Jared interviews Tim Riley about Hanami, an alternative Ruby web framework that prioritizes separation of concerns, modular components, and maintainability over Rails’ monolithic approach. Tim explains how Hanami’s repository pattern for database interactions reduces unintended ripple effects, while its built-in dependency injection improves testability and scalability. He shares the evolution of Hanami, its integration with dry-rb and ROM, and the project’s commitment to fostering an inclusive, sustainable community. With ongoing efforts to enhance accessibility and documentation, Hanami aims to offer Ruby developers a flexible, well-structured alternative for building applications while staying within the familiar Ruby ecosystem.

Links:

Hanami Website

Tim Riley’s Website

Tim Riley on Mastodon

Hanami GitHub Repository

dry-rb GitHub Repository

ROM-rb GitHub Repository

Dead Code Podcast Links:

Jared’s Links:

Andrew’s Balatro Cards Demo

Hosted on Acast. See acast.com/privacy for more information.

Hole-y Diver (with Cyrus Omar and Andrew Blinn)

Tue, 18 Feb 2025 14:00:00 GMT

In this Dead Code podcast episode, Cyrus Omar and Andrew Blinn discuss Hazel, an innovative programming language and editor designed to handle incomplete programs by providing continuous feedback and partial code execution, similar to dynamic languages, while maintaining a robust type system. Hazel’s unique graphical editor allows domain-specific visual representations, such as sliders for integers and playing cards for data manipulation, making programming more intuitive and tactile. The team highlights collaborations with climate scientists for interactive data work and explores Hazel’s potential across various domains like hardware design and mathematics. Future developments include “probes” for live runtime data visualization within code, with the hope that Hazel’s novel approach will inspire broader adoption in the programming community.

Links:

Hazel Website

Andrew Blinn’s Website

PROPL Workshop Paper

Dead Code Podcast Links:

Jared’s Links:

YAMLScript Official Website

Hosted on Acast. See acast.com/privacy for more information.

Yet Another Podcast Episode (with Ingy döt Net)

Tue, 11 Feb 2025 14:00:00 GMT

In this episode of Dead Code, Jared interviews Ingy döt Net, co-creator of YAML, about its origins, unexpected rise in popularity—especially within the Ruby community—and its evolution into a widely used configuration language. Ingy shares insights into YAMLScript, a new programming language he developed to address YAML’s limitations, enabling more powerful configuration and data transformation through a Lisp-like approach. By leveraging Clojure and GraalVM, YAMLScript offers cross-language compatibility and improves YAML’s usability in environments like Kubernetes and Helm. The conversation explores broader industry trends in serialization, the challenges of maintaining a widely adopted format, and Ingy’s philosophy of acmeism, which promotes language-agnostic tooling. He also discusses YAMLScript’s warm reception at KubeCon and its inclusion in programming education platforms like Exercism.

Links:

YAMLScript GitHub Repository

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Zero Allocations (with Joel Drapper)

Tue, 04 Feb 2025 14:00:00 GMT

In this episode of Dead Code, Jared interviews software engineer Joel Drapper about his open-source projects in the Ruby ecosystem. They discuss Phlex, a view framework that allows developers to build HTML components using pure Ruby, eliminating the need for templating languages like ERB. Joel also introduces Literal, a library for reducing boilerplate in object creation with built-in type validation, and Quickdraw, an experimental test runner optimized for multi-core execution. The conversation concludes with Yippee, a SQLite-centric full-stack Ruby framework designed for simplicity and performance, challenging conventional Rails architectures. Joel shares insights on how these projects streamline development while embracing SQLite’s growing viability in production applications.

Links:

Phlex

Literal

Stephen Margheim (@fractaledmind on Bluesky)

Joel Drapper (@joel.drapper.me on Bluesky)

Dead Code Podcast Links:

Jared’s Links:

Camping GitHub Repository

Hosted on Acast. See acast.com/privacy for more information.

Let’s Go Camping (with Karl Oscar Weber)

Tue, 28 Jan 2025 14:00:00 GMT

In this Dead Code episode, host Jared interviews Karl Oscar Weber about revitalizing Camping, a minimalist Ruby web framework originally created by “Why the Lucky Stiff.” Karl shares his 14-year programming journey, his passion for Ruby, and the challenges of modernizing Camping while preserving its compact, esoteric design under five kilobytes. He introduces updates like plugins (“Camping Gear”) and compatibility with newer Ruby features, emphasizing Camping’s educational value and simplicity. Beyond the technical, Karl discusses fostering inclusivity in the Ruby community, countering exclusionary attitudes, and creating spaces that welcome underrepresented developers. Jared commends Karl’s efforts to honor Ruby’s quirky, fun spirit while addressing cultural issues, highlighting the broader impact small projects can have on shaping tech communities.

Links:

Why’s (Poignant) Guide to Ruby

Sequel Gem Documentation

Roda GitHub Repository

Cuba GitHub Repository

Andrew Tate Background (Wikipedia)

Metroid Series Overview (Wikipedia)

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Event Horizon (with Ismael Celis)

Tue, 21 Jan 2025 14:00:00 GMT

In this episode of Dead Code, Jared Norman hosts Ruby developer and consultant Ismael Celis to discuss event sourcing—a data storage model that records historical events to derive the current state of an application, offering benefits like accurate audit trails and reduced complexity. Ismael explains how event sourcing contrasts with traditional CRUD systems by focusing on a flat sequence of events rather than intricate relational models, making it particularly useful in e-commerce and microservices. He highlights his experimentation with event sourcing in Ruby, aiming to combine its simplicity with Ruby’s expressiveness, and mentions existing tools like Rails Event Store, Sequence, and Eventide. Offering practical advice, Ismael suggests starting small with simple Ruby scripts to grasp the concept before adopting established libraries. The episode underscores the potential for event sourcing to streamline debugging and enhance adaptability in dynamic systems.

Links:

Ismael Celis on Twitter

Ismael Celis on GitHub

Ismael’s Website

Rails Event Store

Eventide Documentation

Dead Code Podcast Links:

Jared’s Links:

The Hedy Programming Language

Hosted on Acast. See acast.com/privacy for more information.

For Whom The Compiler Tolls (with Felienne Hermans)

Tue, 14 Jan 2025 14:00:00 GMT

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

Elm Programming Language

Edgar Dijkstra’s EWDs

Ruby Programming Language

Rust Programming Language

Dead Code Podcast Links:

Jared’s Links:

JP's Ruby Concurrency Series

Hosted on Acast. See acast.com/privacy for more information.

Violent Sleep of Concurrency (with JP Camara)

Tue, 07 Jan 2025 14:00:35 GMT

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:

What Color is Your Function?

Async Gem

Concurrent Ruby

Meshuggah – Violent Sleep of Reason

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

‘Twas The Night Before Christmas

Tue, 24 Dec 2024 14:00:14 GMT

In this whimsical holiday-themed episode of the Dead Code podcast, Jared dives into the much-anticipated release of Ruby 3.4, framing the technical updates in a festive, poetic rendition of 'Twas the Night Before Christmas. Listeners are treated to a charming narrative where Ruby's creator, "Saint Matz," embodies a coding Santa Claus, delivering these updates to the community with flair.

Dead Code Podcast Links:

Jared’s Links:

Rebecca Murphey on LinkedIn

Hosted on Acast. See acast.com/privacy for more information.

Why and Why Now? (with Rebecca Murphey)

Tue, 17 Dec 2024 14:00:01 GMT

In this episode of Dead Code, Jared speaks with Rebecca Murphey, Field CTO at Swarmia, about the critical importance of written communication in engineering organizations. Rebecca shares insights from her experiences at Indeed and Stripe, emphasizing how clear, concise, and audience-focused communication can drive alignment, mitigate risks, and advance careers. She discusses frameworks like SCQA (Situation, Complication, Question, Answer) and practical strategies, including critical reading and trimming unnecessary details, to improve technical communication. The conversation also explores how AI tools like ChatGPT are reshaping written communication, the shifting role of junior engineers in a more constrained industry, and the need to understand broader business contexts. The episode underscores that strong communication is as vital as coding skills for thriving in today’s tech landscape.

Links:

Dead Code Podcast Links:

Jared’s Links:

TRICK (The Ruby International Obfuscated Code Competition)

Hosted on Acast. See acast.com/privacy for more information.

Advent of Weird Ruby Code

Tue, 10 Dec 2024 14:00:00 GMT

In this episode of Dead Code, Jared Norman and guests Andrew, Sofia, and Senem discuss their experiences with Advent of Code, an annual programming challenge with Christmas-themed puzzles. They share how the challenge fosters creativity, improves coding skills, and allows for unique problem-solving approaches, particularly using Ruby’s powerful tools like Tally and each_cons. The group reflects on their goals, from practicing domain-driven design and test-driven development to simply having fun writing unconventional code. Jared highlights his focus on creativity over competition, streaming his solutions on Twitch, while the guests explore how Advent of Code inspires learning outside their day-to-day work.

Links:

Advent of Code

Jared's Twitch Stream

Super Good

Project Euler

LeetCode

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Predatory Infrastructure (with Noah Gibbs)

Tue, 03 Dec 2024 14:00:55 GMT

In this episode of Dead Code, Jared Norman and guest Noah Gibbs, author of Rebuilding Rails and Mastering Software Technique, discuss programming as an art form rather than purely a business or engineering practice. They explore how programming, much like traditional art, thrives on creativity and self-expression, with languages like Ruby enabling this through flexibility and elegance, even at the cost of performance. Noah critiques the modern tech ecosystem for prioritizing profit over innovation, stifling creativity with rigid business structures. Highlighting parallels between programming and traditional art education, he advocates focusing on skill and craft instead of monetary incentives. Jared reflects on how these ideas challenge his perspective as a software company owner, urging listeners to consciously define their motivations and reclaim programming as a creative pursuit. The episode, produced by Mandy Moore, invites developers to rethink their relationship with their craft and the systems shaping their work.

Links:

Codefol.io

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

RubyConf Post-Mortem

Tue, 26 Nov 2024 14:00:17 GMT

In this episode of Dead Code, host Jared Norman shares highlights from RubyConf in Chicago, reflecting on its exceptional programming and his personal connection to the venue, dating back to RailsConf 2014. Memorable talks included Matz’s keynote on Ruby's future, Aaron Patterson’s optimization insights, Enrique Mogollan’s exploration of Ruby's boundaries, and Yusuke Endoh’s innovative code-as-art presentation. Jared also discussed standout moments like Tom Enebo’s talk on the Piet programming language and Nick Means’ keynote on AI and aviation. Looking ahead, Jared announced plans for RailsConf 2025 in Philadelphia, the Advent of Code livestreams, and his new newsletter for behind-the-scenes updates.

Links:

Dead Code Podcast Links:

Jared’s Links:

Tightly Coupled Book Club

Hosted on Acast. See acast.com/privacy for more information.

Symphony of Automation (with Aji Slater)

Tue, 19 Nov 2024 14:00:11 GMT

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:

Diana Montalion's Book on Systems Thinking: Learning Systems Thinking

Hosted on Acast. See acast.com/privacy for more information.

Everything is an Experiment (with Jessica Kerr)

Tue, 12 Nov 2024 14:00:29 GMT

In this Dead Code episode, Jessica Kerr (Jessitron) joins host Jared Norman to explore the evolving nature of experimentation and learning in software development. Jessica reflects on her shift from valuing software’s determinism to embracing the unpredictability of distributed systems and human factors. She explains that traditional scientific methods, like A/B testing, often fall short in complex, socio-technical environments, where dynamic learning and observing real-world impacts are crucial. At Honeycomb, she practices a holistic approach to experimentation, viewing each system and team as a “symmathesy”—a mutual learning environment where insights flow between developers and the software. Jessica emphasizes that continuous improvement relies on knowledge sharing and storytelling within teams, urging developers to approach retrospectives as genuine feedback loops to refine processes, connect with teammates, and foster growth.

Links:

Jessica's Website – Jessica’s personal website, where she shares her blog and more about her work.

Symmathesy Talk at RubyConf – Jessica's talk about symmathesy from RubyConf

Graceful.Dev – Jessica's platform for short educational videos.

Jessitron’s Twitter

Jessitron’s Mastodon

Jessitron’s Instagram

Honeycomb.io

Agile Manifesto

Dead Code Podcast Links:

Jared’s Links:

Andrew’s Book, High Performance Postgres For Rails

Hosted on Acast. See acast.com/privacy for more information.

Postgres and Destroy (with Andrew Atkinson)

Tue, 05 Nov 2024 14:00:34 GMT

In this episode of Dead Code, host Jared Norman talks with Andrew Atkinson, author of High Performance Postgres For Rails, about the benefits and recent updates to Postgres. Andrew shares why he prefers Postgres for its reliability, extensibility, and independence from corporate control, making it ideal for applications with complex or fluctuating data needs. They delve into Postgres 17’s new features, like JSONB functions for querying JSON as if it were relational data, improved MERGE operations for simplified upserts, and new returning clauses. Andrew’s book is designed for application developers seeking to optimize performance and security beyond ORM abstractions, with practical examples to help them harness Postgres’s full potential. Jared and Andrew agree that Postgres’s robust tools can elevate an application’s reliability, especially in high-demand scenarios like e-commerce, encouraging developers to explore its depth.

Links:

Andrew Atkinson’s Blog

Postgres 17 Release Notes

Scenic Gem (for managing database views in Rails)

JSON Path Syntax (for querying JSON data in Postgres)

pgvector extension for Postgres (for AI and vector search applications)

TimescaleDB Extension (for time series data)

Citus Extension (for distributed Postgres workloads)

Dead Code Podcast Links:

Jared’s Links:

Code Thesaurus GitHub Repository

Hosted on Acast. See acast.com/privacy for more information.

Twitching Hour (with Rachael Wright-Munn)

Tue, 29 Oct 2024 13:00:53 GMT

In this Dead Code podcast episode, Jared Norman interviews Chael Wright-Munn (ChaelCodes) about the benefits of working openly through activities like live streaming and contributing to open-source projects. Chael emphasizes how creating a "library of examples" through public coding can enhance a developer’s skills, build their professional network, and preserve their achievements beyond their current job. She offers practical advice on starting a stream, such as using OBS software, focusing on community building, and engaging in structured projects like Hacktoberfest. The discussion highlights the value of maintaining a visible presence in the tech community, whether through streaming, open-source contributions, or other public-facing efforts, as a way to retain knowledge and showcase work, even across job changes.

Links:

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Master of Generators (with Garrett Dimon)

Tue, 22 Oct 2024 13:00:32 GMT

In this episode of Dead Code, host Jared Norman interviews Garrett Dimon about the benefits of using Rails generators for automating tasks and maintaining consistency in Rails applications. Garrett, a seasoned developer, shares how he transitioned to Ruby and Rails and delved deep into using generators to simplify repetitive tasks, automate file creation, and adhere to Rails conventions. He discusses the advantages of generators, such as reducing errors, saving time, and creating a streamlined workflow that benefits entire teams. Garrett also talks about writing a book on the topic of making generators more accessible and highlights how they can be customized for various needs, offering significant productivity gains for developers. The episode emphasizes the enduring value of Rails generators in improving development processes and project structure.

Links:

Garrett Dimon's Website

The Book on Generators

Rails Framework

Thor Gem

Fireside.fm

Dead Code Podcast Links:

Jared’s Links:

Organization for Ethical Source

Hosted on Acast. See acast.com/privacy for more information.

Hammer Smashed Argument (with Coraline Ada Ehmke)

Tue, 15 Oct 2024 12:40:29 GMT

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:

Coraline Ada Ehmke

Contributor Covenant

Hippocratic License

RailsConf

Madison Ruby

Richard Stallman

United Nations Universal Declaration of Human Rights

Dead Code Podcast Links:

Jared’s Links:

Hosted on Acast. See acast.com/privacy for more information.

Benevolent Dictatorship (with Mat, Noah, Sofia, and Chris)

Tue, 08 Oct 2024 16:00:45 GMT

In this episode, host Jared Norman and SuperGood teammates and guests Mat Harvard, Sofia Besenski, Noah Silvera, and Chris Todorov recap their experiences at Rails World 2024. They discuss the unique venue in Toronto, key takeaways from David Heinemeier Hansson's keynote on making Rails more accessible, and the shift towards on-prem solutions over services like Heroku. The panel highlights technical talks on scaling Postgres, Shopify’s automated Rails upgrade process, and debates on Kamal 2.0’s proxy features. They also explore Rails’ future direction, technical debt management, and the Rails boot process.

Links:

Dead Code Podcast Links:

Jared’s Links:

J.B. Rainsberger's website

Hosted on Acast. See acast.com/privacy for more information.

Fear-Driven Development (with J. B. Rainsberger)

Tue, 01 Oct 2024 13:23:00 GMT

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

RSpec for Rails

Rails Testing Documentation

Extreme Programming

Dead Code Podcast Links:

Jared’s Links:

Kevin Newton on Twitter (X)

Hosted on Acast. See acast.com/privacy for more information.

Pondering the Prism (with Kevin Newton)

Tue, 24 Sep 2024 15:07:57 GMT

In this episode of Dead Code, Jared interviews Kevin Newton, Staff Software Engineer at Shopify, about his work on Ruby's new parser, Prism. Kevin explains how Prism was created to address the limitations of Ruby's original parser by providing a portable, error-tolerant solution that unifies the ecosystem, replacing multiple outdated parsers used across different tools. They discuss the challenges of parsing Ruby's complex syntax, including quirky features like heredocs and regular expressions, and how Prism was designed for better control and performance. Kevin emphasizes the community-driven effort behind the project, making it more accessible to contributors, and shares how Prism will advance Ruby tooling in future releases.

Links:

Kevin Newton's blog

Kevin Newton's GitHub

Crafting Interpreters

Rails World Conference

ESLint

Dead Code Podcast Links:

Jared’s Links:

Faker Library (GitHub Repository)

Hosted on Acast. See acast.com/privacy for more information.

Supercritical Gem (with Stefanni Brasil)

Tue, 17 Sep 2024 16:47:08 GMT

In this episode of the Dead Code Podcast, Jared Norman talks with Stefanni Brasil, a Senior Software Developer at thoughtbot and co-founder of hexdevs, about career growth, open source, and mentorship in tech. Stefanni shares her non-traditional path into software development and her passion for helping mid-level developers advance through her program "Get to Senior," which addresses both technical and non-technical skills. They discuss the challenges of career progression, the importance of understanding company promotion dynamics, and the need for developers to focus on leadership and communication skills. Stefanni also highlights the ethical concerns surrounding open-source contributions, advocating for companies to financially support the projects they benefit from. The conversation ends with a reflection on the role of AI, productivity, and the value of sharing knowledge publicly to strengthen the tech community.

Links:

Stefanni Brasil's Blog

hexdevs

Rails World Conference

Ruby on Rails Community

GitHub Copilot

Tidelift

ChaelCodes (Rachel's Social Media)

The Survey Mentioned

Dead Code Podcast Links:

Jared’s Links:

Stack Overflow Survey of Developers

Hosted on Acast. See acast.com/privacy for more information.

Triplicate Multi-Nested Ternary (with Hilary Stohs-Krause)

Tue, 10 Sep 2024 13:00:06 GMT

Hilary Stohs-Krause and Jared discuss the importance of applying accessibility principles to coding environments, emphasizing how it benefits both developers and end-users. Hilary, a senior software engineer, shares insights from her talk at Madison Ruby, highlighting how small changes, like using descriptive variable names, avoiding acronyms, and incorporating linters, make code more readable and maintainable. These practices not only support programmers with disabilities, such as ADHD or vision impairments, but also improve the overall coding experience for all developers. Hilary argues that creating accessible code benefits everyone by reducing cognitive load, improving communication, and fostering more inclusive workplaces, even though such practices are often deprioritized in fast-paced, capitalist environments.

Links:

Madison Ruby Conference

ADA (Americans with Disabilities Act

Dyslexia in Programmers

ADHD in Programmers

Plain Language Writing Guidelines

Go Programming Language

FactoryBot

Dead Code Podcast Links:

Jared’s Links:

Standard ML Documentation

Hosted on Acast. See acast.com/privacy for more information.

Purely Functional Ideas (with Harmony)

Tue, 03 Sep 2024 16:15:57 GMT

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:

Fennel Language

Lua Programming Language

ReScript Language

OCaml

Uiua Language

APL Language

Conway’s Game of Life Interactive Simulator

Advent of Code

Project Euler

React.js

Fennel VS Code Extension

ReScript VS Code Extension

Uiua VS Code Support

Emacs Fennel Mode

Emacs ReScript Support

Dead Code Podcast Links:

Jared’s Links:

Madison + Ruby Conference

Hosted on Acast. See acast.com/privacy for more information.

All Those Letters That You Do (with Jim Remsik)

Tue, 27 Aug 2024 13:00:55 GMT

In this episode of "Dead Code," host Jared Norman interviews Jim Remsik, a Ruby developer and founder of the consultancy Flagrant. Jim shares his journey from .NET to Ruby on Rails, reflecting on the early days of the Ruby community and the impact of its vibrant, collaborative environment on his career. He discusses the importance of mentorship and nurturing junior developers, stressing the need for more opportunities within the Ruby community to help them grow into senior roles. Jim also talks about his passion for organizing events like Madison + Ruby, which recently returned after a hiatus, highlighting how conferences and meetups play a vital role in building connections and strengthening the community. The conversation underscores the value of stepping up to contribute to programming communities, whether through organizing, speaking, or participating in events.

Links:

Jim Remsik on LinkedIn

Flagrant Consultancy

Dead Code Podcast Links:

Jared’s Links: