Graceful.Dev

We know that Value Objects are useful; today we'll meet a gem that makes them easier to build. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-223-equalizer/

Today we look at a lesser-known but handy pair of methods on Strings. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-222-string-partition/

Lies, Damn Lies, and Github Stars zurl.co/RX8K4

Just what are we doing here, people? Find the full video on the @gracefuldev YouTube channel. zurl.co/9An3z #ai #agenticcoding

Since Ruby 2.1, def returns a symbol. In this episode we'll take a look at why this matters, and how it might change the way we define methods. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-221-def-return-value/

Where do we draw the line between objects differntiated only by state, and objects differentiated by their class? That's the question we'll examine in this episode. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-220-type-and-class/

What does it mean to work with people using agents? Episode 6 of Machines of Code and Grace zurl.co/z7ojs

Today we learn about Ruby gem that makes it easier to build immutable value objects. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-219-adamantium/

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 Claude wrote it before you’ve even finished the first line. https://graceful.dev/podcast/its-called-etiquette-and-we-dont-have-it-yet/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-218-spaceship-revisited/

Today, a story about a refactoring that went south, and turned out not to be a refactoring at all. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-217-redesign/

In today's episode, we explore a practical application of the famous "tell, don't ask" principle. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-216-tell-don-t-ask/

Today we look at Ruby's grep method, and explore the idea of matching objects by example. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-215-grep/

Today we puzzle through a design problem that threatens to result in dozens of extra methods.  https://graceful.dev/courses/tapastry/modules/2014/topic/episode-214-conversion-ratio/

Today's topic is "conversion protocols", an extensible way to enable safe, automatic conversions between types. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-213-conversion-protocol/

Today's episode deals with a small matter of style, one that can have an impact on how easy it is to refactor code. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-212-more-of-same/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-211-protected/

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 advant https://graceful.dev/courses/tapastry/modules/2014/topic/episode-210-implicit-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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-209-implicit-and-explicit-conversion/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-208-lenient-conversions/

In this episode we create a function for converting arbitrary values into Feet objects. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-207-conversion-function/

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 coer https://graceful.dev/courses/tapastry/modules/2014/topic/episode-206-coercion/

New for subscribers: @jessitron.bsky.social demystifies system prompts! https://youtu.be/Db6OacUxf9U?si=WeEZK79xA_SpinHk

In this episode we meet a Ruby standard module that makes it easy to make classes comparable and sortable. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-205-comparable/

New episode for subscribers! This time, we're adding "hands" to our nascent coding agent. 👐 graceful.dev/topic/chat-p... youtu.be/_Xsa0alWiWY

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-204-hash-equality/

Today's dish is an exploration of how Ruby is able to quickly look up keys in hashes. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-203-hash-table/

Today's episode deals with the concepts of identity and equality - what makes one object equal to another. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-202-identity-and-equality/

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?? https://graceful.dev/podcast/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?? https://graceful.dev/podcast/we-need-more-scaffolding/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-201-immutable-object/

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 object https://graceful.dev/courses/tapastry/modules/2014/topic/episode-200-quantity/

Today's episode demonstrates an easy way to build big regular expressions out of little ones. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-199-regexp-union/

Jessitron and Avdi discuss using an agent with Obsidian, Change Implementation Records, and closing the verification loop. https://graceful.dev/podcast/how-do-we-give-it-eyeballs/

@jessitron and @avdi.codes discuss using an agent with Obsidian, Change Intent Records, and closing the verification loop. https://graceful.dev/podcast/how-do-we-give-it-eyeballs/

To work effectively with LLMs as coding assistants, we must first understand what they are… and what they aren’t. New full episode for subscribers: https://graceful.dev/topic/llms-are-completion-machines/ https://youtu.be/5btarU8JVHA

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-198-decorator-transparency/

Today we explore the Decorator pattern, with the help of the SimpleDelegator standard library. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-197-decorator/

Avdi and Jessitron talk about brown M&Ms, ASCII trumpets, and why we need telltales to ensure our agents haven't missed something important. https://graceful.dev/podcast/no-poop-candy/

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! https://graceful.dev/courses/tapastry/modules/2014/topic/episode-196-string-templates/

Following on from the last episode, today we look at some more advanced uses of Ruby's string formatting features. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-195-advanced-string-formats/

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 https://graceful.dev/courses/tapastry/modules/2014/topic/episode-194-string-format/

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. https://graceful.dev/podcast/historically-is-like-six-months-ago/

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 manipulatio https://graceful.dev/courses/tapastry/modules/2014/topic/episode-193-pathname/

Introducing... "Machines of Code and Grace" - the official Graceful.Dev podcast! In this inaugural episode, Jessitron explains how she's using AI Feature Owners to avoid accidental regressions. https://graceful.dev/podcast/ive-often-wished-i-could-fork-myself/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-192-filenames/

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. https://graceful.dev/courses/tapastry/modules/2014/topic/episode-191-virtual-proxy/

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

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

Today's episode is about a semantic convention for error handling that I learned from Jim Weirich. graceful.dev/courses/tapa...