Today we learn about Ruby gem that makes it easier to build immutable value objects.

In which Jessitron and Avdi admit that nobody — themselves included — is ever fully caught up on the AI news cycle, and dig into why an email can smell like

In episode 205 we introduced the spaceship () operator, but we also introduced an incompatibility with how Ruby's builtin comparisons work. Today we'll address this oversight.

Today, a story about a refactoring that went south, and turned out not to be a refactoring at all.

In today's episode, we explore a practical application of the famous "tell, don't ask" principle.

Today we look at Ruby's grep method, and explore the idea of matching objects by example.

Today we puzzle through a design problem that threatens to result in dozens of extra methods. 

Today's topic is "conversion protocols", an extensible way to enable safe, automatic conversions between types.

Today's episode deals with a small matter of style, one that can have an impact on how easy it is to refactor code.

The distinction between "public" and "private" method visibility in Ruby is pretty obvious. But when should we use "protected" visibility? This episode attempts to answer that question.

Have you ever wondered why Ruby has both #to_i and #to_int methods? Or both #to_a and #to_ary? In today's episode we'll answer this question, and look at how we can use implicit conversion methods to our advantage.

In this episode we look at how to convert our Feet objects back to core numeric types. In the process, we gain the ability to use our Feet objects in format strings.

For core types like Float, Ruby has both conversion methods (#to_f), and conversion functions (Float()). When should we use one vs. the other? This episode attempts to answer that question.

In this episode we create a function for converting arbitrary values into Feet objects.

Ruby generally doesn't allow mixing of types without explicit conversion. So have you ever wondered why it's possible to multiply 2.3 (a float) by 5 (an integer)? In today's episode we'll discover how Ruby's implicit coercions work, and how to apply them to our own custom numeric-like classes.

New for subscribers: Jessitron demystifies the system prompt!

In this episode we meet a Ruby standard module that makes it easy to make classes comparable and sortable.

YouTube video by GracefulDev

Building on the previous episode on hash tables, today we tackle the concept of hash equality: how Ruby decides if two objects are the same for the purpose of use as hash keys.

Today's dish is an exploration of how Ruby is able to quickly look up keys in hashes.

Today's episode deals with the concepts of identity and equality - what makes one object equal to another.

In which Jessitron and Avdi discuss using LLM agents to make improvement to development environments for both LLM and human coders. Also: the vindication of microservices??

In which Jessitron and Avdi discuss using LLM agents to make improvement to development environments for both LLM and human coders. Also: the vindication of microservices??

In this episode we learn how mutability can lead to bugs in Value Objects... and how we can eliminate these types of bugs once and for all.

In today's episode we take a look at a storied problem in software: defects caused by accidentally mixing-up the units of measurement used in calculations. And we kick off a multi-part series exploring how to build objects that represent physical quantities.

Today's episode demonstrates an easy way to build big regular expressions out of little ones.

Jessitron and Avdi discuss using an agent with Obsidian, Change Intent Records, and closing the verification loop.

Jessitron and Avdi discuss using an agent with Obsidian, Change Intent Records, and closing the verification loop.

Get two weeks of Graceful.Dev Pro for free: https://graceful.dev/youtube

In today's episode we look at a potential complication of using the Decorator pattern, and discuss how to resolve it by enforcing Command/Query Separation.

Today we explore the Decorator pattern, with the help of the SimpleDelegator standard library.

Avdi and Jessitron talk about brown M&Ms, ASCII trumpets, and why we need telltales to ensure our agents haven't missed something important. Jo

Have you ever wanted a way to customize the format of certain generated strings, but felt like ERB or some other templating language was overkill? If so, today's episode should satisfy!

Following on from the last episode, today we look at some more advanced uses of Ruby's string formatting features.

Sometimes Kernel#puts and string interpolation doesn't give us the level of control we want over our program's output. When we need to control numeric formatting and field widths, we need to understand string formats. And that's what this episode is all about!

In which Jessitron and Avdi discuss the merits of larger and smaller LLMs, and the challenges of code review in codebases with a lot of history.

While the File methods are great for occasional use, for programs that deal extensively in filenames we need to bring out the big guns. Today we'll get an overview of Pathname, Ruby's swiss army knife for path manipulation.

Jessitron and Avdi discuss defining AI "Feature Owners" in order to avoid accidental breakage.Watch the video versionShow notesJessitron's

Ruby provides a lot of tools for breaking filenames into their component parts, but they aren't always well documented. Today's episode combines goes over some basics as well as a tip you might not be familiar with.

When loading domain objects from an external service, it can be expensive to load up associated objects with them. Today's episode takes a look at a pattern for transparently lazy-loading such associations.

Today we look at the humble String#gsub method, and learn that it has some surprising tricks up its sleeve.

In today's episode, we'll examine how the availability of tools to aid refactoring can change how we write code.

Today's episode is about a semantic convention for error handling that I learned from Jim Weirich.

Today we go a little deeper into keyword arguments in Ruby 2.0/2.1, covering a few use cases we didn't cover in the last episode.

Today's episode is a guide to transitioning various hash argument idioms to Ruby 2.0/2.1 keywords.

Today's dish is a refactoring approached from two different perspectives. Enjoy!

Recently we looked at the Sequel library for interacting with SQL databases. Today, we'll use Sequel again to play with the native JSON support in PostgreSQL 9.3.

We've used the "ghost object" pattern to lazily load attributes of a model object. And we've made a macro to easily declare "ghost-loadable" attribute accessors. Today we complete the generalization of ghost loading by extracting a module that makes it easy for any model object to declare lazily-loaded attributes.

When is it appropriate to metaprogram? Today's episode looks at one situation in which it may be a good choice.