Dead Code

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 BlogJean’s GitHubIvo Anjo’s GVL Profiling Talk (RubyConf)Ivo Anjo’s GVL Profiling ToolJean’s Blog Post: “So, You Want to Remove the GVL?”Jean’s Blog Post: “The Mythical IO-Bound Rails App”Ruby Ractors DocumentationDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

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 BlogJames Gayfer’s Mastodon profileSQLx library for RustRepository PatternHanami FrameworkPhoenix FrameworkEctoHotwireAll models are wrong, but some are usefulDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

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.ioRoguelike Radio PodcastRoguelike Dev Community on RedditRoguelikes Community on RedditMark R. Johnson’s Game (Ultima Ratio Regum)Mark R. Johnson’s Twitter (X)Mark R. Johnson’s BlueskyDarren Grey’s BlueskyDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronJared’s Newsletter & WebsiteEpisode Transcript

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 WebsiteTim Riley’s WebsiteTim Riley on MastodonHanami GitHub Repositorydry-rb GitHub RepositoryROM-rb GitHub RepositoryTilt (Ruby template engine support)Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronEpisode Transcript

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 WebsiteAndrew Blinn’s WebsiteAndrew’s Balatro Cards DemoPROPL Workshop PaperDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronEpisode Transcript

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 WebsiteYAMLScript GitHub RepositoryExercismMake a LispKubeCon PrismHelmGraalVMMkDocs Material Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronEpisode Transcript

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:PhlexLiteralStephen Margheim (@fractaledmind on Bluesky)Joel Drapper (@joel.drapper.me on Bluesky)Dead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronEpisode Transcript

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 TwitterIsmael Celis on GitHubIsmael’s WebsiteRails Event StoreEventide DocumentationDead Code Podcast Links:MastodonXJared’s Links:MastodonXtwitch.tv/jardonamronEpisode Transcript