Practical Object-Oriented Design in Ruby

Why design matters — the true cost of change, treating software as an arrangement of message-passing objects, and design as the art of managing dependencies.

Making classes do one thing — the SRP, the TRUE test, hiding instance variables behind methods, and isolating data structures so change stays cheap.

Recognizing, isolating, and inverting dependencies — dependency injection, depending on abstractions, and choosing the direction dependencies should point.

Designing the messages between objects — public vs private interfaces, asking for 'what' not 'how', context independence, and the Law of Demeter.

Across-class interfaces defined by behavior, not class — recognizing hidden ducks behind case-on-class and responds_to? checks, and trusting objects by what they do.

Classical inheritance done right — recognizing where it fits, refactoring concrete classes into an abstract superclass, and using the template method pattern with hooks instead of super.

Sharing behavior across unrelated classes with Ruby modules — recognizing roles, writing inheritable module code, understanding method lookup, and the rules of well-behaved inheritance (Liskov, hooks, shallow hierarchies).

Building objects out of parts — composition vs inheritance, the has-a relationship, modeling with factories and roles, and how to choose between inheritance, modules, and composition.

Writing tests that pay for themselves — what to test, when to test, how to test incoming and outgoing messages, and keeping the test suite cheap to maintain as the design evolves.