Facebook Twitter Pinterest
  • Alle Preisangaben inkl. MwSt.
Nur noch 2 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Menge:1
Design Patterns in Ruby (... ist in Ihrem Einkaufwagen hinzugefügt worden
Gebraucht: Gut | Details
Verkauft von FatBrain
Zustand: Gebraucht: Gut
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 3 Bilder anzeigen

Design Patterns in Ruby (Addison-Wesley Professional Ruby) (Englisch) Gebundene Ausgabe – 10. Dezember 2007

5.0 von 5 Sternen 2 Kundenrezensionen

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Preis
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Gebundene Ausgabe
"Bitte wiederholen"
EUR 48,41
EUR 42,89 EUR 27,75
7 neu ab EUR 42,89 8 gebraucht ab EUR 27,75
click to open popover

Wird oft zusammen gekauft

  • Design Patterns in Ruby (Addison-Wesley Professional Ruby)
  • +
  • Eloquent Ruby (Addison-Wesley Professional Ruby)
  • +
  • Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby)
Gesamtpreis: EUR 110,88
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Produktinformation

Produktbeschreibungen

Synopsis

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." --Peter Cooper "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." --Mike Stok "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.

Buchrückseite

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."

-Peter Cooper

"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."

-Mike Stok

""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.

Alle Produktbeschreibungen

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
2
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Stern
0
Beide Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel

Top-Kundenrezensionen

Format: Gebundene Ausgabe
Ich habe mir lange überlegt, ob ich das Buch, Design Patterns in Ruby, kaufen sollte. Schließlich bin ich Pattern-vorgebildet und ob ich ein Muster nun in C++, Java oder in Ruby implementiere, wo soll da der Unterschied sein. Das sind doch alles objektorientierte Sprachen.

Aber so ist es nicht. Wer dieses Buch liest, merkt schnell: Ruby ist erfrischend anders. Manche Muster sind schon in der Programmiersprache eingebaut, manche in der Standard-Bibliothek. Und für viele gibt es neben der java-artigen Implementierung noch eine zweite, die viel kürzer und eleganter ist. Beipielsweise durch den Method-missing-Mechnismus von Ruby.

Diese Art der Ruby Programmierung war neu für mich und so habe ich viel über Ruby gelernt. Man kann sagen, für mich war das Buch eine echter "Eye-Opener". Und den Schreibstil mag ich auch. Allerdings nutzen sich die anfangs witzigen Einführungen schnell ab. Deswegen gebe ich 5 Sterne für den Inhalt und vier für die Form. Und da mir der Inhalt wichtiger ist, insgesamt 5.
Kommentar 13 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Format: Gebundene Ausgabe Verifizierter Kauf
Nach einer kurzen Einfuehrung der Ruby-Basics geht es direkt los mit den Pattern: Allgemeine Problemstellung des Pattern, erlaeuterung des Loesungsvorschlags der gang-of-four, Umsetzung in Ruby und abschliessend ein Blick ueber den Tellerrand. Gespickt mit passenden Codebeispielen ergibt sich so ein sehr guter Einblick in jedes Pattern und ein ebenso tiefer in die Sprache selber.

Eindeutige Empfehlung!!
Kommentar 3 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: HASH(0x969c236c) von 5 Sternen 39 Rezensionen
47 von 47 Kunden fanden die folgende Rezension hilfreich
HASH(0x91e129a8) von 5 Sternen One of the best Ruby books ever 7. Februar 2008
Von Ricardo Dapaz - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
Warning: This book is not a reference!!!
Well, it could be but it probably won't need to be as each concept is explained so well that you will remember when to apply this pattern or that pattern for every situation. The author is engaging and funny making this quite a book turner for a technical book. I almost read half the book on the 2 hour commuter flight between Perth and Karatha. Every chapter starts with a little anectode about the author's past life events and how these are related to the use of a particular pattern. The examples are well thought out and the author also discusses Ruby specific implementation details as well as providing valuable insights into how each pattern is used in the existing Ruby codebase.

I come from a Python/C/C++/Java background and have been tinkering around with ruby for a while but without really "getting it" and understanding what the fuss was about. The same could be said about design patterns. After reading this book I have finally grokked, not only Ruby but the value and power of design patterns. I can now say that I truly understand exactly why there is such a hype about Ruby. The whole method_missing thing, singleton support, ability to clone classes, etc. This language really represents the future of programming - today - and this book delivers on its intent.

This is simply one of the best technical books that I have read in a long time and I thoroughly recommend it, especially for an intermediate Ruby programmer and even those who know OO concepts and principles but may be new to Ruby.
24 von 24 Kunden fanden die folgende Rezension hilfreich
HASH(0x91e12a08) von 5 Sternen Valuable Resource 13. Januar 2008
Von David L. Richards - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
I just finished this book, cover to cover. I rarely read books like this all the way through. I scan them and keep them around in case they help me out of a jam. But this book is different. It is formative in the sense that the original Gang of Four (GoF) book on patterns was formative: it asks us to think about our problems in fresh ways.

One important part of this book, however, stresses the use and overuse of these patterns. Olsen emphasizes that this isn't a competition to use all the patterns. Whoever has the most patterns doesn't necessarily win. Whoever uses code gracefully and simply does. It reminds me of the talk by Marcel Molina Jr. at RubyConf 07, speaking about what makes code beautiful. It's the proportion, integrity, and clarity that makes beautiful code. I.e., we keep the code as simple as we can, keep it focused on the problem at hand, and we do it clearly. This book warns against misuse or abuse of patterns as much as it teaches the patterns themselves.

Another thing that I found very useful about this book is it suggests simpler ways for my existing code. This tells me that, though I was happy with the function of what I could do once, the form can improve that it doesn't fall apart in the face of future iterations.

Finally, I enjoy how each chapter evolves. We start with a rigorous interpretation of the GoF patterns, then Olsen introduces simpler ways to implement the ideas that take into account Ruby's available economies. So, we write simpler code, understand the tradoffs of the various alternative implementation methods, and understand the patterns themselves more concretely.

Other than the occasional loose editing that come up from time to time, I really wouldn't change what was written. I would have enjoyed more chapters on other patterns, even some that are outside the scope of the GoF book. But that's just a reflection of my respect for Olsen's love of the material and skill in teaching it.

If you're picking up Ruby to write Rails code, maybe start with the Agile Development book. If you've finished your first personal Rails project, or you have other uses of Ruby in mind, I'd suggest this as the next book you pick up. After this book, I'd next suggest The Ruby Way by Hal Fulton. That's probably the fastest way to pick up Ruby in a professional context.
9 von 9 Kunden fanden die folgende Rezension hilfreich
HASH(0x91e12e40) von 5 Sternen Design Patterns make sense with this book in Ruby 27. Juli 2008
Von Craig Maloney - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
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.
10 von 12 Kunden fanden die folgende Rezension hilfreich
HASH(0x917c0228) von 5 Sternen Great book about some of the more advanced things that can be done with Ruby 5. Januar 2008
Von Karl L - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
At first glance, Ruby looks like any other dynamically typed language. Statements are sequential, it boast strong support for Object Oriented Programming, and it has all the basic control structures with which are are intimately familiar. After working with Ruby, and the constantly evolving Rails web framework, it's clear that Ruby is different from Python or Java, and that its differences make it very special.

That's why Design Patterns in Ruby is a great reference book, not because it discusses the Gang of Four patterns that any experienced developer knows by heart after years of practice, but because it demonstrates practical usages of many of the more advanced topics in the Ruby language. Extending an Object or Class at runtime, on-the-fly? Check. Magic methods? Check. Blocks, Procs and lambdas? Check. DSLs? Metaprogramming? Check, check. This book is short, but it has everything needed for a developer to understand the advanced concepts of Ruby.

Take warning, though. If you are just starting in Ruby, this is NOT the book for you, and many concepts will go over your head.
6 von 7 Kunden fanden die folgende Rezension hilfreich
HASH(0x917c030c) von 5 Sternen Very helpful, particularly for newcomers to ruby 28. März 2008
Von James Stewart - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
For many the idea of bringing design patterns to ruby is a terrifying one. Having taken refuge from over-engineered java projects (or for that matter, attempts to apply java engineering approaches to a somewhat dynamic language like PHP) the baggage that often goes along with design patterns isn't what a recent convert is looking for. But as I mentioned in my last review of a design patterns volume, and series editor Obie Fernandez highlights in his foreword, design patterns don't have to be used that way and maintain merit when used as a source of collective experience and shared language.

Russ Olsen's book does a good job of stepping through the key patterns from the Gang of Four's initial offering, showing how they can be applied to and simplified with Ruby, introducing along the way various uses of blocks, mix-ins, and other powerful features of the language that may be unfamiliar to newcomers. Each chapter highlights how the pattern can be used or abused, sounding a note of caution to dissuade unthinking embrace of every pattern between its covers. It's clearly written with a nice balance of code to prose.

Towards the end of the book a couple of "new" patterns are offered, particularly "internal DSLs", "meta-programming" and "convention over configuration." Opinions differ over whether of those can really be considered patterns in the general sense of the term. Certainly those concepts are examples of a community gradually refining its approaches to common problems, but at least two of them are considerably more conceptual and abstract than most of the other patterns in the book. Perhaps the best way to understand them is as giving an insight into the working patterns of the ruby community approaches problems, and pointers to topics worthy of more exploration.

That usage of the final few chapters gives some indication of the probable audience for this book. It seems best suited to those who have dabbled with ruby but don't yet have much experience. A general sense of syntax is all you'll need going in, but you'll come away with a much stronger sense of the language's features than that. Similarly it'll work well for those with a general sense of the major patterns but who could do with a refresher, maybe while transitioning from java or other "enterprisey" development to ruby.

While it won't have the same general appeal of other titles in the series like The Ruby Way, Second Edition: Solutions and Techniques in Ruby Programming (2nd Edition) (Addison-Wesley Professional Ruby Series) and The Rails Way (Addison-Wesley Professional Ruby Series), this is a handy volume in a series that is making strong contributions to the ruby book market.

Disclaimer: I was sent a copy of this book for review by the publisher. There were a few pages missing due to a printing defect so I wan't able to read parts of chapters 13 or 14.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.