Skip to main content
The Bike Shed

441: The Pickaxe Book with Noel Rappin

39 min episode · 2 min read
·
Noel Rappin

Episode

39 min

Read time

2 min

Topics

Software Development, Philosophy & Wisdom, Science & Discovery

AI-Generated Summary

Key Takeaways

  • Dynamic typing philosophy: Ruby's flexibility allows reopening classes and runtime modifications, enabling rapid adaptation to changing requirements without compiler constraints, though teams must guard against a specific class of runtime errors through testing and code review practices.
  • Static typing trade-offs: Typing only method return values (not inputs) may preserve dynamic language flexibility while providing tooling support. This approach lets developers specify guaranteed outputs like "returns User object" without constraining input parameters, balancing both paradigms effectively.
  • Technical book credibility: Authors writing under established imprints like Pragmatic must prioritize community consensus over personal preferences. Readers take examples literally, so code samples must work exactly as written or readers abandon the book, making accuracy critical for maintaining trust.
  • Ruby style consensus: Use Justin Searles' Standard Ruby linter as baseline for community-accepted conventions like two-space indentation and underscore variable names. This captures widely-agreed practices rather than individual preferences, ensuring the reference reflects actual Ruby developer norms across teams.

What It Covers

Noel Rappin discusses updating Programming Ruby (the Pickaxe Book) to Ruby 3.3, exploring static versus dynamic typing debates, and balancing community consensus with personal opinions when writing canonical technical references for the Ruby community.

Key Questions Answered

  • Dynamic typing philosophy: Ruby's flexibility allows reopening classes and runtime modifications, enabling rapid adaptation to changing requirements without compiler constraints, though teams must guard against a specific class of runtime errors through testing and code review practices.
  • Static typing trade-offs: Typing only method return values (not inputs) may preserve dynamic language flexibility while providing tooling support. This approach lets developers specify guaranteed outputs like "returns User object" without constraining input parameters, balancing both paradigms effectively.
  • Technical book credibility: Authors writing under established imprints like Pragmatic must prioritize community consensus over personal preferences. Readers take examples literally, so code samples must work exactly as written or readers abandon the book, making accuracy critical for maintaining trust.
  • Ruby style consensus: Use Justin Searles' Standard Ruby linter as baseline for community-accepted conventions like two-space indentation and underscore variable names. This captures widely-agreed practices rather than individual preferences, ensuring the reference reflects actual Ruby developer norms across teams.

Notable Moment

Rappin realized he spent a dozen years positioning himself to update the canonical Ruby book, staring at the repository for two weeks before making his first edit, intimidated by the responsibility of maintaining a beloved community resource.

Know someone who'd find this useful?

Episode Transcript

Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at Thoughtbot about developing great software. I'm Joelle Kenville. And I'm Steph Nieman, and we're also joined by a very special guest, Noel Rapin. Hi. I'm here. Yes, you are. I'm here to talk about bike sheds. Is this are we not talking about bike sheds? You know what? That is actually a different show. Oh, damn. I'm just kidding. Alright. Software it is then. Yeah. And together, we're here to share a little bit about what we've learned along the way. I have derailed us already. I'm sorry. No. It's great. This is what we do on the bike shed. Let's go. So, Noel, the question that we open with every week is what's new in your world? I have to give the self promotional answer, answer, I guess. Like, what's new in my world is that I have this book out, the pickaxe book, programming Ruby three three. I guess it's, like, new relative to previous versions of it, so I'm the coauthor of it. And it is new up to current versions of Ruby. And, also, you know, I just did just as we recorded this, posted a very, very long blog post about ways to work around static typing in Ruby by using Ruby's dynamic type system, which is a thing that I have been, like, writing about online for a bit in these very long, probably nobody reads to the end blog posts. So that's that's what's new with me professionally, I guess. I'm really curious about that static typing, dynamic typing area that you've been digging in. What is it there that particularly excites you or gets you interested? So this started with some discussions with work colleagues about sorbet and the value of sorbet and static typing within Ruby. And I think I have a sort of idiosyncratic vision of that because unlike a lot of Ruby developers who came to Ruby through Java or other statically typed languages, I guess a lot of Ruby developers came through Python now. But I came to Ruby through small talk, so I am extremely comfortable with the idea that there are no static types and that you can still build large systems with it. And I got into trying to extract why I felt that way and what it was specifically about the discussion around static typing in Ruby that really rubbed me the wrong way and which is essentially, there's a line of thought that it is always good to be more strict, and it's always good to be more static, that there's never ever any downside to being more static, that it is a good in and of itself. That is apparently the only thing in software design that has, like, only benefits and never has any costs. And and that sort of attitude, I was trying to fairly, but to also say, like, hey. There are …

Get the full transcript (8,680 words) + summary by email — free

One-time email with the complete transcript and AI summary of this episode. No account needed.

One email, no spam. We’ll also show you what SignalCast does.

Browse all The Bike Shed transcripts →

You just read a 3-minute summary of a 36-minute episode.

Get The Bike Shed summarized like this every Monday — plus up to 2 more podcasts, free.

Pick Your Podcasts — Free

Keep Reading

Books, tools, and gear mentioned in this episode

SignalCast may earn commission on purchases via these links. As an Amazon Associate, SignalCast earns from qualifying purchases.

Books

Tools

  • Standard RubyRecommended

    by Justin Searles

    Use Justin Searles' Standard Ruby linter as baseline for community-accepted conventions like two-space indentation and underscore variable names.

More from The Bike Shed

We summarize every new episode. Want them in your inbox?

Similar Episodes

Related episodes from other podcasts

Explore Related Topics

This podcast is featured in Best Cybersecurity Podcasts (2026) — ranked and reviewed with AI summaries.

Read this week's Software Engineering Podcast Insights — cross-podcast analysis updated weekly.

You're clearly into The Bike Shed.

Every Monday, we deliver AI summaries of the latest episodes from The Bike Shed and 192+ other podcasts. Free for one show.

Start My Monday Digest

No credit card · Unsubscribe anytime