- Hardcover: 384 pages
- Publisher: Addison-Wesley Professional; 1 edition (December 20, 2007)
- Language: English
- ISBN-10: 0321490452
- ISBN-13: 978-0321490452
- Product Dimensions: 9.4 x 1 x 7.1 inches
- Shipping Weight: 1.6 pounds (View shipping rates and policies)
- Average Customer Review: 40 customer reviews
- Amazon Best Sellers Rank: #790,826 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Design Patterns in Ruby 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Frequently bought together
Customers who bought this item also bought
From the Back Cover
Praise for "Design Patterns in Ruby"
""Design Patterns in Ruby" documents smart ways to resolve many problems that Ruby developers commonly encounter. Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. He clearly explains each idea, making a wealth of experience available to Ruby developers for their own daily work."
-Steve Metsker, Managing Consultant with Dominion Digital, Inc.
"This book provides a great demonstration of the key 'Gang of Four' design patterns without resorting to overly technical explanations. Written in a precise, yet almost informal style, this book covers enough ground that even those without prior exposure to design patterns will soon feel confident applying them using Ruby. Olsen has done a great job to make a book about a classically 'dry' subject into such an engaging and even occasionally humorous read."
"This book renewed my interest in understanding patterns after a decade of good intentions. Russ picked the most useful patterns for Ruby and introduced them in a straightforward and logical manner, going beyond the GoF's patterns. This book has improved my use of Ruby, and encouraged me to blow off the dust covering the GoF book."
""Design Patterns in Ruby" is a great way for programmers from statically typed objectoriented languages to learn how design patterns appear in a more dynamic, flexible language like Ruby."
-Rob Sanheim, Ruby Ninja, Relevance
Most design pattern books are based on C++ and Java. But Ruby is different-and the language's unique qualities make design patterns easier to implement and use. In this book, Russ Olsen demonstrates how to combine Ruby's power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.
After reviewing the history, concepts, and goals of design patterns, Olsen offers a quick tour of the Ruby language-enough to allow any experienced software developer to immediately utilize patterns with Ruby. The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and "mixins" for easier code reuse.
Fourteen of the classic "Gang of Four" patterns are considered from the Ruby point of view, explaining what problems each pattern solves, discussing whether traditional implementations make sense in the Ruby environment, and introducing Ruby-specific improvements. You'll discover opportunities to implement patterns in just one or two lines of code, instead of the endlessly repeated boilerplate that conventional languages often require.
"Design Patterns in Ruby" also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based "Convention Over Configuration" pattern, designed to help integrate entire applications and frameworks.
Engaging, practical, and accessible, "Design Patterns in Ruby" will help you build better software while making your Ruby programming experience more rewarding.
About the Author
Russ Olsen has been building software for more than twenty-five years. He has led projects through several generations of programming technologies, from FORTRAN to C to C++ to Java, and now Ruby. He has been using and teaching Ruby since 2002. Olsen writes the popular technology blog Technology As If People Mattered (http://www.russolsen.com).
Top customer reviews
As a newer software engineer, it's really valuable to recognize the patterns I've seen and used and to put names to them. I think it's intended audience is intermediate software engineers who are looking for new ways to structure their code and want to learn some terms that help articulate code structure to other engineers.
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.
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:
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:
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.
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.
The book is a hybrid reference/Ruby-introduction book which provides the best of both worlds -- I was able to read it cover-to-cover without losing interest, something I could never quite accomplish with the original GoF Design Patterns text. Each chapter also functions as a modular unit, with concise introductions and conclusions that will be great on a day when I pull it off my shelf for use as a reference book. The Design Patterns provide a nice playpen for the sections on Ruby coding practices and features, and the coding sections give a better context for the Patterns.
Each Pattern is discussed in theory and in real-world code, and the author is very clear about the benefits and pitfalls of employing them. In addition, the book provides a solid, likable profile of the Ruby language without the evangelizing common in other books. Code examples are concise and useful, and the writing style is humorously engaging without falling into the trap where engineers-turned-authors suddenly believe they are stand-up comedians and sprinkle every paragraph with a multitude of grating jokes. There were a few mistakes in the text, but all of them were already captured and corrected on the book's web site.
In my library of tech books, the best books, the ones I constantly revisit, are not the ones that show me how to do something -- they are the ones that place what I do in a wider context and show me the possibilities of what CAN be done. Although I do not currently use Ruby in my day-to-day work, I can see this book becoming invaluable when that day comes.