Nate Klaiber said
If you have been programming for any extended period of time, I am sure you have started to see different patterns emerging out of your tasks. You may find you are doing the same thing over and over again, solving problems that you had previously solved in another project. These patterns can vary from smaller chunks of re-usable code, to manage the sending and receiving of email, all the way to watching over a part of your application and triggering notifications to another part of your application. This book, Design Patterns in Ruby takes several of the principles found in the widely known book, Design Patterns by The Gang of Four, and applies them to Ruby. It's a mixture of the theory behind the design patterns, and then hands-on practice applying it to your Ruby applications. While this book is centered around patterns in Ruby, it is not about teaching you Ruby. There is a brief primer in the beginning, but it comes with the understanding that you already know a little bit about the Ruby language. Now it's time to check out some of the patterns presented in this book.
WHAT ARE PATTERNS?
The book starts off with a chapter devoted to giving background to design patterns and how they can help you build better applications. This chapter isn't a history lesson. The main points of this chapter teach you about awareness. They teach you how to look at your applications, and when and where patterns could best be applied. He gives what he calls Patterns for Patterns while developing:
Separate out the things that change from the things that stay the same.
Program to an interface, not an implementation.
Prefer composition over inheritance.
Delegate, delegate, delegate.
You ain't gonna need it.
These principles provide us the glasses with which to look through as we assess our code. You will want to keep these in the back of your mind as you read through the rest of the book.
WHAT IS RUBY?
As I stated in the beginning, this book isn't about teaching you Ruby. However, the author does take the second chapter to walk you through the basics. This chapter simply shows you a bit of the syntax, types, and constructs. This intro is very brief, but probably enough to provide a reference throughout the rest of the book if you haven't worked with Ruby before. With this primer into Ruby, the author wraps up the first part of the book and we are now ready to move on to the 14 patterns covered in this book.
THE PATTERNS
Spotting patterns might not always be easy, even with the guidelines given in the first chapter. One of the strengths of this book is that each chapter poses a different problem and then tackles is using the suggested pattern. This allows you to see it in action, and allows you to get the wheels spinning on how the pattern is used and where else it could be used. After walking through each of the patterns, we are presented with a nice wrap-up of the pattern.
This book is not very long in length, so I won't go into great detail with each of the patterns, as they are covered very well in each chapter. You need the context to understand how all of the pieces fit together. So, without providing too much information, here is a list of the patterns covered in the book:
Template method
Strategy
Observer
Composite
Iterator
Command
Adapter
Proxy
Decorator
Singleton
Factory
Abstract Factory
Builder
Interpreter
If you are like me, then you will have read these chapters and be left with a desire to instantly start researching, practicing, and applying what you have learned. But we aren't done quite yet, there is still one more section to go. We now know what the patterns look like. We have seen the examples done solely in Ruby. Everything makes sense. But can we do more? Now we shift gears to look at patterns found in the Ruby language itself.
THE PATTERNS + RUBY
The Ruby language itself has several patterns that make programming Ruby fun and elegant. The last part of this book shows us a few of those patterns, as they can be used extensively while building your application patterns. If you have ever browsed through the Ruby on Rails source code, then you will have seen all of the patterns listed above, as well as the patterns in Ruby. Here are a few of those:
Domain-Specific Languages
Meta-programming
Convention over configuration
Ruby is such an elegant language to work with, and it is due in many parts to these patterns found within the language. These aren't patterns solely used by Ruby, but the English-like nature of Ruby makes it fun to both read and write with these patterns.
PARTING THOUGHTS
This book fits nicely with the Addison Wesley Professional Ruby Series, but doesn't require you to read all other books in the series to fully comprehend. While the progression of this book was done very well, starting you off with a discussion of patterns and Ruby, then diving right into the patterns, I did find myself reading this book several times. I didn't read it several times because I didn't understand it, but simply to read with a new outlook on how and where these patterns could be applied, or are currently applied out in the wild. I find this book not only to be very informative, but also an excellent reference as I look to solve different problems. If you are a programmer, you should definitely read Design Patterns. If you are a Ruby programmer, you should then read Design Patterns in Ruby.
Alessio Marchetti said
This book is about using Ruby to implement most of the Design Patterns described in the GoF book ([...]
If GoF is a reference, this book is almost like a novel: each chapter is dedicated to a pattern and is based on the author's past experiences (not just professional) to give it a reassuring justification.
The reason why I read the book? I was curious to find how Ruby's unique features could be used to implement those Design Patterns. Was I satisfied? Please find all stars in my ranking. And since the journey is not the destination, I also found interesting concepts along the way.
One of the things I would like to mention about the journey is how well the book highlights when, in designing your architecture, inheritance provides a too-strong coupling. All those dynamic features of Ruby are explained that can help in modularizing your architecture using composition and delegation instead of using inheritance.
The book concludes by briefly touching on meta-programming, domain-specific languages (DSL) and convention over configuration, three patterns not mentioned in the GoF book, but that "feel at home" within a Ruby environment.
D. Brent Chapman said
If you're already a programmer, this book an excellent way to learn Ruby. It shows how to apply a variety of common and largely language-independent programming structures ("design patterns") in "the Ruby way". Along the way, you get a great introduction to what makes Ruby unique, and the idioms commonly used in the Ruby community. I especially liked that the author often showed multiple implementations of each pattern, each implementation being more elegant and Ruby-esque than the last, and included a discussion of when each might (and might not!) be appropriate. I also appreciated the helpful discussion of the ways you might shoot yourself in the foot with each pattern in Ruby, as well as the pointers to where you could find the pattern used in Ruby "in the wild" (in various software freely available on the Internet).
Adam Wasserman said
This is a marvelous book, ideal if you're an experienced object-oriented programmer who wants to learn to use Ruby with the idioms particular to it, and not remain frozen in the techniques of traditional, statically typed object-oriented languages. Ruby is a dynamically typed language with many unique features, and this book was invaluable in my learning to use it as such. There are 16 design patterns covered, 3 of which are particular to the Ruby development environment. With each pattern is presented first the traditional approach using Ruby as a straightforward OO language, followed by the Ruby approach which takes advantage of the idioms and techniques particular to the Ruby language. With each pattern is introduced a new Ruby idiom, making the book a tutorial in advanced Ruby programming techniques.
Craig Maloney said
I never really understood the need for Design Patterns. After reading several blogs, and listening to other programmers, I thought that Design Patterns might even somehow be harmful to my programming education. I felt that just by learning what they were, I'd somehow pollute my thinking to the point where I wouldn't be able to program without seeing a pattern in there somewhere. When I heard of the book Design Patterns in Ruby, I flinched. What good could possibly come from introducing Design Patterns into Ruby, I asked myself? Fortunately, my initial prejudices were unfounded. Design Patterns in Ruby is not some secret plot to turn all of the Ruby programmers into mindless drones; it is a very thorough introduction to Ruby, Design Patterns, and Object Oriented Programming concepts. Design Patterns in Ruby helped me to finally look critically at Design Patterns, and see them as something not to be feared, but as something that could be useful, even in my Ruby programming.
Design Patterns in Ruby is written with the idea that while the reader might be a good programmer, they may have somehow missed what Design Patterns are, or the reader might not know much about Ruby. The first two chapters rectify this by introducing the reader to what exactly these Design Patterns are. The author explains precisely which of the 14 of the original 23 "Gang of Four" patterns are covered in the book, and reasons why the 14 patterns were chosen. Chapter 2 is a quick introduction to Ruby, just to ensure everyone is on the same page. The author, in a single chapter, clearly explained concepts that other books I have read couldn't clearly convey, even after several chapters. Any doubts that I had of the author's abilities in explaining Design Patterns in a way that I would understand were completely gone by these chapters.
The actual Design Patterns in Design Patterns in Ruby have a similar format throughout the rest of the book. First, a small anecdote begins the chapter, explaining either a real-life situation where the patterns would be handy, or tying the pattern to one of the other patterns in the book. The meat of the chapter describes how one would implement the pattern, usually starting with a direct port from another language like C++ or Java, and gradually working it into something more Ruby-like by the end of the section. After the pattern is worked into a more Ruby-like format, the author then describes how to really abuse the pattern. Lastly, the author points out where this pattern is used in the Ruby, Rails, or other Ruby code, followed by a quick summary. This format works quite well, especially for programmers just starting in both Ruby and Design Patterns, while advanced programmers will learn better and more effective ways for implementing (or abusing) the patterns. Providing where the pattern is used in the code is also an excellent learning tool for the reader, and gives a baseline for the reader on where to look for more examples. The format also makes the book engaging. I found myself wanting to read the book, which is an experience I can't say I shared with the original Gang of Four Design Patterns book.
In addition to 14 of the Gang of Four patterns, the author talks about three Ruby-specific patterns. The first is the Domain Specific Language (DSL) pattern. Rather than defaulting to discussing Active Record (arguably the most famous DSL in Ruby), the author actually creates a DSL called "PackRat" which is a language for managing backups. The second pattern is Metaprogramming, which is ubiquitous in Ruby. The last pattern in the book is Configuration Over Configuration, the mantra of Rails. Each of these patterns compliments the other patterns in the book, and add to the original patterns discussed earlier in the book.
Design Patterns in Ruby is an exceptional book. It distills the best of the "Gang of Four" patterns that are of significance to Ruby Programmers, while adding several patterns that show up throughout Ruby and Ruby on Rails code. The author's style and the book's format make for an easy and informative reading experience. I can heartily recommend this book for all Ruby developers, both beginners and experts, and can especially recommend this book for those like myself who didn't think the original Design Patterns was anything to give attention. Design Patterns in Ruby has earned a permanent place on my shelf.
Comments