This is a really good book, and I liked it a lot, but it feels weird to give a programming book 5 stars

If you call yourself a ruby programmer, you should read this book.

Sandi Metz has done a great job explaining how to write maintainable applications, in a way that is accessible to programmers
at any skill level. Her book is concise (less than 250 pages, including the index), but jam-packed with great nuggets
of practical advice and coding techniques that you can start applying immediately in your projects. Her style is easy
to read, with many code examples that show you the evolution of code, as an application changes and is refactored.

Among the techniques discussed:

* Use dependency injection to avoid coupling between objects. (Makes them easier to test too)
* To write great APIs, focus on the messages being sent between objects. (She shows why you would actually __want to__
use a UML diagram)
* By creating role tests and applying them to test doubles, you can avoid the 'leaving the dream' problem, where stubs in tests obscure the fact that objects interfaces have changed.

Very solid introduction to OO topics, code design and testing. The language was a little bit too poetic for me, as not native speaker it makes me harder to grasp the content, but the content itself is worth recommendation.

I really liked this book. A lot of it was generic OOP advice, but I learned some new things about OOP, Ruby, and testing. Definitely worth the read. I would recommend this book to anyone that knows Ruby and wants to learn more about OOP in Ruby.

I wish I had read this book earlier in my career. It combines both my love of bikes and my profession of writing ruby. This book seems to be geared toward a more intermediate-level programmer, but it could be read at any stage in one's career and shed light on important design concepts. I don't doubt that I will read this book cover-to-cover again in the future, and use it as a reference for design and architecture questions in the future.

No matter what language you primarily code in, this book is a great Object Oriented primer/refresher. I wish I would have read it years ago when I started working with Java. Some things are specific to Ruby, but the concepts are universal. Sandi writes very clearly and doesn't add content just for the sake of doing so. The book is full of practical examples using a domain we're all familiar with. She explains the rules, when to break them and why and what you should be looking out for so you don't paint yourself into a corner.