Protected

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.

graceful.dev

Implicit Conversion

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.

graceful.dev

Explicit Conversion

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.

graceful.dev

Lenient Conversions

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.

graceful.dev

Conversion Function

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

graceful.dev

Coercion

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.

graceful.dev

System Prompt is the First Message (Teaser)

New for subscribers: Jessitron demystifies the system prompt!

youtu.be

Comparable

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

graceful.dev

Chat Plus Tools Equals Agent (Preview)

YouTube video by GracefulDev

youtu.be

Hash Equality

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.

graceful.dev

Hash Table

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

graceful.dev

Identity And Equality

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

graceful.dev

"We need more scaffolding"

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??

graceful.dev

"We need more scaffolding"

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??

graceful.dev

Immutable Object

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.

graceful.dev

Quantity

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.

graceful.dev

Regexp Union

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

graceful.dev

"How do we give it eyeballs?"

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

graceful.dev

"How do we give it eyeballs?"

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

graceful.dev

LLMs are completion machines - Teaser

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

youtu.be

Decorator Transparency

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.

graceful.dev

Decorator

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

graceful.dev

"No poop candy!"

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

graceful.dev

String Templates

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!

graceful.dev

Advanced String Formats

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

graceful.dev

String Format

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!

graceful.dev

"Historically is like six months ago"

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.

graceful.dev

Pathname

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.

graceful.dev

"I've often wished I could fork myself…"

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

graceful.dev

Filenames

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.

graceful.dev