Book review - Practical OO Design in Ruby

Sun, Jul 14, 2013
Practical Object Oriented Design in Ruby - Sandi Metz

I just worked my way through Sandi Metz’ “Practical Object Oriented Design in Ruby” and found it to be a very good book with clear examples and points made about a subject that can otherwise be cloudy and complex.

The book generally explains how a Ruby program might follow SOLID design principles, but wisely avoids getting hung up on definitions and theory, and instead teaches by example (and counter-example).

The book touches on all of the SOLID principles, but I felt that (again wisely) it spent more time on the 2 more important principles:

It does this across 9 chapters:

  1. Object Oriented Design
  2. Designing Classes with a Single Responsibility
  3. Managing Dependencies
  4. Creating Flexible Interfaces
  5. Reducing Costs with Duck Typing
  6. Acquiring Behavior Through Inheritance
  7. Sharing Role Behavior with Modules
  8. Combining Objects with Composition
  9. Designing Cost-Effective Tests

While I do favor OO designs, I’m not a big fan of inheritance, so I’m glad it was handled with care and I felt the suggestions to favor shallow hierarchies, or prefer duck typing and composition over inheritance where possible is great advice.

I also appreciated the many practical comments about deferring decisions and waiting for patterns to emerge instead of engineering for a predicted future.

I personally took away a greater appreciation for duck-typing. So many OO design books concentrate on is-a vs has-a relationships, but of equal (or perhaps greater) importance for long-term flexible design is the behaves-like-a relationship.


This is definitely not an architecture-astronaut book - it gives practical advice with many concrete examples, but also has lots of little nuggets of advice that are ripe for a highlighter pen…

“You do not have to know where you’re going to use good design practices to get there. Good practices reveal design.”

“Once you begin to treat your objects as if they are designed by their behavior rather than their class, you enter into a new realm of expressive flexible design”

“Well designed applications are constructed of reusable code. Small, trustworthy self-contained objects with minimal context, clear interfaces, and injected dependencies are inherently reusable.”

“Creating a hierarchy has costs”

“Refactoring - a precise process that alters code via tiny, crab-like steps and carefully, incrementally, and unerringly transforms one design into another.”

“Tests give you confidence to refactor constantly. Efficient tests prove that altered code continues to behave correctly”

To Summarize

This is a great book for the intermediate ruby developer, its easy to read, clean and concise. At 240 pages it is the perfect size for a quick read - and the color coded example code is always appreciated.

Advanced developers might find it somewhat familiar, but its presented in a way that reinforces those best practices and still a worthwhile read to join alongside other highly recommended ruby books: