Hosted on Acast. See acast.com/privacy for more information.
Hosted on Acast. See acast.com/privacy for more information.
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
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
Domain-Specific Languages (DSLs)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
RailsConf 2024 Talk (YouTube)
RailsConf 2024 Slides (Speaker Deck)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
Sign up at jardo.dev/anarchyagile to enter the 50th episode giveaway!
Justin Searls: Find his writing, projects, and podcast Breaking Change at justin.searls.co
Growing Object-Oriented Software, Guided by Tests by Steve Freeman & Nat Pryce
Extreme Programming Explained by Kent Beck
The Secrets of Consulting by Jerry Weinberg
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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
“CEOs Are Publicly Boasting About Reducing Their Workforces With AI” – Futurism
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:
Hosted on Acast. See acast.com/privacy for more information.
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:
Why’s (Poignant) Guide to Ruby
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:
Hosted on Acast. See acast.com/privacy for more information.
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:
Mond’s Blog – Here Comes the Moon
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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.
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:
Hosted on Acast. See acast.com/privacy for more information.
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:
Episode 10 with Kevin Newton on Prism
Episode 38 with Carson Gross on HTMX
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
DRY Principle (Don’t Repeat Yourself)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
Works on My Machine (Substack)
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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:
Programming Ruby (The Pickaxe Book)
why’s (poignant) Guide to Ruby
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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.
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.
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:
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.
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.
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.
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
Dead Code Podcast Links:
Jared’s Links:
Hosted on Acast. See acast.com/privacy for more information.