Postgres And Destroy (with Andrew Atkinson) Dead Code podcast

Jared’s Links:

#Tech #Jared Norman #Software Development #Programming #Software Engineering #Software #Computer Science

Episode Transcript

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

42 episodes

Dead Code

Postgres and Destroy (with Andrew Atkinson)

Dead Code

published about a year ago

MP3•Episode home

Links:

Andrew Atkinson’s Blog

Andrew’s Book, High Performance Postgres For Rails

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:

#Tech #Jared Norman #Software Development #Programming #Software Engineering #Software #Computer Science

Episode Transcript

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

42 episodes

All episodes

Dead Code

1
Poisoning the Well (with Heydon Pickering) 37:34

3 days ago37:34

37:34

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. Heydon’s Blog Webbed Briefs (Heydon’s video series) Eleventy (11ty) JS DOM robots.txt nofollow attribute Dadaism Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Deterministic Simulation (with Stevan) 28:27

10 days ago28:27

28:27

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: Stevan’s Blog Erlang Elixir Agda Idris TLA+ Roc Jepsen Antithesis BEAM Let it crash philosophy Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Brutality of Behaviour (with Carson Gross) 45:58

17 days ago45:58

45:58

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 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) Hyperscript Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
GOTO Precedence Hell (with Noratrieb) 28:55

24 days ago28:55

28:55

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” Rust C Programming Language Ruby Lisp Go Rescript rustfmt Clippy Prettier Nora’s Website Nora’s Mastodon Nora’s GitHub Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Cursed Return (with Nicole Tietz-Sokolskaya) 32:14

4 weeks ago32:14

32:14

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 Can I Ethically Use LLMs? Talon Voice Software Recurse Center Deconstruct Conf AMP Project Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Frozen to Death (with Kevlin Henney) 54:47

6 weeks ago54:47

54:47

In this episode of Dead Code, Jared talks with Kevlin Henney about the importance of immutability in software development, particularly as a strategy for reducing bugs related to state and concurrency. Kevlin explains that while many programming languages default to mutable state, treating state change as a privilege—not a right—can lead to more maintainable, less error-prone code. He discusses how immutability strengthens encapsulation, simplifies reasoning about systems, and avoids issues like race conditions and deadlocks, especially in multi-threaded environments. Kevlin also emphasizes that these design choices are architectural, not just implementation details, and that teams benefit from shared philosophies around state management. The conversation ties into broader programming culture and offers practical insights for developers, especially those working in languages like Ruby, where mutability is common but evolving. Links: Kevlin Henney’s article – “Restrict Mutability of State” Book – 97 Things Every Programmer Should Know Open source repo with contributions Overflow collection curated by Shirish Padalkar (includes the “Restrict Mutability of State” essay) RubyConf Mini Providence Talk – Immutable Data Structures RailsConf Talk – Immutable Objects in Practice @Kevlin on Bluesky @Kevlin@mastodon.social Kevlin Henney on LinkedIn Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Pattern Imprisonment (with Joan Westenberg) 40:50

7 weeks ago40:50

40:50

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 Joan Westenberg’s Website Ghost Mastodon Pixelfed Lemmy Fairphone Murena / /e/OS Vivaldi Qwant Ecosia Where Wizards Stay Up Late: The Origins of the Internet Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Ordinary Corrupt Memory Love (with Jean Boussier (byroot)) 33:25

8 weeks ago33:25

33:25

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 Talk (RubyConf) 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: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
All Models Are Wrong (with James Gayfer) 26:23

9 weeks ago26:23

26:23

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 James Gayfer’s Mastodon profile SQLx library for Rust Repository Pattern Hanami Framework Phoenix Framework Ecto Hotwire All models are wrong, but some are useful Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Permadeath (with Roguelike Radio) 50:44

10 weeks ago50:44

50:44

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: Seven-Day Roguelike Challenge (7DRL) on itch.io 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: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Jared’s Newsletter & Website Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Lethal Dependency Injection (with Tim Riley) 45:50

11 weeks ago45:50

45:50

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 Tilt (Ruby template engine support) Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Hole-y Diver (with Cyrus Omar and Andrew Blinn) 36:46

12 weeks ago36:46

36:46

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 Andrew’s Balatro Cards Demo PROPL Workshop Paper Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Yet Another Podcast Episode (with Ingy döt Net) 35:34

13 weeks ago35:34

35:34

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 Official Website YAMLScript GitHub Repository Exercism Make a Lisp KubeCon Prism Helm GraalVM MkDocs Material Dead Code Podcast Links: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Zero Allocations (with Joel Drapper) 49:16

14 weeks ago49:16

49:16

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: Mastodon X Jared’s Links: Mastodon X twitch.tv/jardonamron Episode Transcript Hosted on Acast. See acast.com/privacy for more information.…

Dead Code

1
Let’s Go Camping (with Karl Oscar Weber) 20:45

15 weeks ago20:45