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.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter mobile phone number.

Kindle Price:    622.00
includes free wireless delivery via Amazon Whispernet

These promotions will be applied to this item:

Some promotions may be combined; others are not eligible to be combined with other offers. For details, please see the Terms & Conditions associated with these promotions.

Deliver to your Kindle or other device

Deliver to your Kindle or other device

Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby) by [Metz, Sandi]
Kindle App Ad

Practical Object-Oriented Design in Ruby: An Agile Primer (Addison-Wesley Professional Ruby) 1st , Kindle Edition


See all 2 formats and editions Hide other formats and editions
Price
New from
Kindle Edition
"Please retry"
   622.00

Length: 273 pages Enhanced Typesetting: Enabled Page Flip: Enabled
Language: English

Learn more about purchasing Kindle eBooks

Customers can now buy over 3 million Kindle books on Amazon.in with Indian credit/debit cards, net banking and Amazon.in Gift cards. > Learn More

Product description

Review

 “This is great stuff! Your descriptions are so vibrant and vivid that I’m rediscovering the truth buried in OO principles that are otherwise so internalized that I forget to explore them. Your thoughts on design and knowing the future are especially eloquent.”

—Ian McFarland, President, New Context, Inc.

 

“As a self-taught programmer, this was an extremely helpful dive into some OOP concepts that I could definitely stand to become better acquainted with! And, I’m not alone: there’s a sign posted at work that reads, ‘WWSMD? – What Would Sandi Metz Do?’”

—Jonathan Mukai, Pivotal in NYC

 

“Meticulously pragmatic and exquisitely articulate, Practical Object Oriented Design in Ruby makes otherwise elusive knowledge available to an audience which desperately needs it. The prescriptions are appropriate both as rules for novices and as guidelines for experienced professionals.”

—Katrina Owen, developer, Bengler

 

“I do believe this will be the most important Ruby book of 2012. Not only is the book 100% on-point, Sandi has an easy writing style with lots of great analogies that drive every point home.”

—Avdi Grimm, Author of Exceptional Ruby and Objects on Rails



“While Ruby is an object-oriented language, little time is spent in the documentation on what OO truly means or how it should direct the way we build programs. Here Metz brings it to the fore, covering most of the key principles of OO development and design in an engaging, easy-to-understand manner. This is a must for any respectable Ruby bookshelf.”

–Peter Cooper, editor, Ruby Weekly

 

“So good, I couldn’t put it down! This is a must-read for anyone wanting to do object-oriented programming in any language, not to mention it has completely changed the way I approach testing.”

–Charles Max Wood, video and audio show host, TeachMeToCode.com

 

“Distilling scary OO design practices with clear-cut examples and explanations makes this a book or novices and experts alike. It is well worth the study by anyone interested in OO design being done right and ‘light.’ I thoroughly enjoyed this book.”

–Manuel Pais, editor, InfoQ.com

 

“If you call yourself a Ruby programmer, you should read this book. It’s jam-packed with great nuggets of practical advice and coding techniques that you can start applying immediately in your projects.”

–Ylan Segal, San Diego Ruby User Group

 

“This is the best OO book I’ve ever read. It’s short, sweet, but potent. It slowly moves from simple techniques to more advanced, each example improving on the last. The ideas it presents are useful not just in Ruby but in static languages like C# too. Highly recommended!”

–Kevin Berridge, software engineering manager, Pointe Blank Solutions, and organizer, Burning River Developers Meetup

 

“The book is just perfect! The elegance of Ruby shines but it also works as an A to Z of object-oriented programming in general.”

–Emil Rondahl, C# & .NET consultant

 

“This is an exceptional Ruby book, in which Metz offers a practical look at writing maintainable, clean, idiomatic code in Ruby. Absolutely fantastic, recommended for my Ruby hacker friends.”

–Zachary “Zee” Spencer, freelancer & coach

 

“This is the best programming book I’ve read in ages. Sandi talks about basic principles, but these are things we’re probably still doing wrong and she shows us why and how. The book has the perfect mix of code, diagrams, and words. I can’t recommend it enough and if you’re serious about being a better programmer, you’ll read it and agree.

–Derick Hitchcock, senior developer, SciMed Solutions

 

“I predict this will become a classic. I have an uncomfortable familiarity with programming literature, and this book is on a completely different level. I am astonished when I find a book that offers new insights and ideas, and even more surprised when it can do so, not just once, but throughout the pages. This book is excellently written, well-organized, with lucid explanations of technical programming concepts.”

–Han S. Kang, software engineer and member of the LA Rubyists

 

“You should read this book if you write software for a living. The future developers who inherit your code will thank you.”

–Jose Fernandez, senior software engineer at New Relic

 

“Metz’s take on the subject is rooted strongly in theory, but the explanation always stays grounded in real world concerns, which helped me to internalize it. The book is clear and concise, yet achieves a tone that is more friendly than terse.”

–Alex Strasheim, network administrator, Ensemble Travel Group

 

“This is an amazing book about just how to do object-oriented thinking when you’re programming in Ruby. Although there are some chapters that are more Ruby-specific, this book could be a great resource for developers in any language. All in all, I can’t recommend this book enough.”

–James Hwang, thriceprime.com

 

“Whether you’re just getting started in your software development career, or you’ve been coding for years (like I have), it’s likely that you’ll learn a lot from Ms. Metz’s book. She does a fantastic job of explaining the whys of well-designed software along with the hows.”

–Gabe Hollombe, software craftsman, avantbard.com

 

“In short, this is in my top five programming books I’ve ever read. I believe that in twenty years this will be considered one of the definitive works on object-oriented programming. I plan to re-read it at least once a year to keep my skills from falling into atrophy. If you’re a relatively new, intermediate, or even somewhat advanced OO developer in any language, purchasing this book is the best way I know to level up your OO design skills.”

–Brandon Hays, freelance software developer

Product Description

The Complete Guide to Writing More Maintainable, Manageable, Pleasing, and Powerful Ruby Applications

 

Ruby’s widely admired ease of use has a downside: Too many Ruby and Rails applications have been created without concern for their long-term maintenance or evolution. The Web is awash in Ruby code that is now virtually impossible to change or extend. This text helps you solve that problem by using powerful real-world object-oriented design techniques, which it thoroughly explains using simple and practical Ruby examples.

 

Sandi Metz has distilled a lifetime of conversations and presentations about object-oriented design into a set of Ruby-focused practices for crafting manageable, extensible, and pleasing code. She shows you how to build new applications that can survive success and repair existing applications that have become impossible to change. Each technique is illustrated with extended examples, all downloadable from the companion Web site, poodr.info.

 

The first title to focus squarely on object-oriented Ruby application design, Practical Object-Oriented Design in Ruby will guide you to superior outcomes, whatever your previous Ruby experience. Novice Ruby programmers will find specific rules to live by; intermediate Ruby programmers will find valuable principles they can flexibly interpret and apply; and advanced Ruby programmers will find a common language they can use to lead development and guide their colleagues.

 

This guide will help you

  • Understand how object-oriented programming can help you craft Ruby code that is easier to maintain and upgrade
  • Decide what belongs in a single Ruby class
  • Avoid entangling objects that should be kept separate
  • Define flexible interfaces among objects
  • Reduce programming overhead costs with duck typing
  • Successfully apply inheritance
  • Build objects via composition
  • Design cost-effective tests
  • Solve common problems associated with poorly designed Ruby code

 


Product details

  • Format: Kindle Edition
  • File Size: 17545 KB
  • Print Length: 273 pages
  • Simultaneous Device Usage: Up to 5 simultaneous devices, per publisher limits
  • Publisher: Addison-Wesley Professional; 1 edition (5 September 2012)
  • Sold by: Amazon Asia-Pacific Holdings Private Limited
  • Language: English
  • ASIN: B0096BYG7C
  • Text-to-Speech: Enabled
  • X-Ray:
  • Word Wise: Not Enabled
  • Screen Reader: Supported
  • Enhanced Typesetting: Enabled
  • Average Customer Review: Be the first to review this item
  • Amazon Bestsellers Rank: #78,312 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  • Would you like to tell us about a lower price?


What other items do customers buy after viewing this item?

Customer Reviews

There are no customer reviews yet on Amazon.in
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on Amazon.com (beta) (May include reviews from Early Reviewer Rewards Program)

Amazon.com: 4.7 out of 5 stars 169 reviews
52 of 55 people found the following review helpful
5.0 out of 5 stars Superb content, excellent delivery. 12 September 2012
By Amazon Customer - Published on Amazon.com
Format: Kindle Edition Verified Purchase
This is my favorite tech read so far this year. It takes a straight-forward approach to writing code that you won't hate yourself for a day or month or year later.

The term "design" in the title is not referring to making wild speculative guesses about the future and planning for any number of contingencies, it is about arranging the code so that it is understandable, and to minimize cost and pain.

There is a focus on designing the communication between objects as much as focusing on the structure of the objects themselves, which I found to be extremely interesting. This discussion helped clarify a lot of thoughts and ideas about abstractions and where responsibilities belong, as well as the directions of dependencies -- things that had been rattling around in my brain for a while but that I had trouble applying in the real world. Reading this let me put all these pieces together (and then some) into a coherent whole. Or at least a coherent seed of a whole.

The code examples are simple, but the author manages to wrangle some serious dramatic tension out of every line of code, and they illustrate the concepts covered well enough that I was able to make the leap to applying the concepts in much more complex code bases.

The chapter on testing was sublime. It took an immensely practical approach to which methods to test and which tests to write in order to avoid duplication and brittleness in both tests and designs.

I also appreciated that none of the discussions were about any sort of moral superiority. The discussions were about getting things done. The argument for arranging code nicely wasn't about aesthetics or professional duty, but rather about lowering cost and allowing you to make changes without causing expensive outages and making people frustrated.

Soap boxes? Sure. High horses? Nowhere in sight.

Note: I read a pre-release version of the book. I did not know the author at the time, but sent her quite a lot of feedback, which led to several conversations to clarify. When I waxed enthusiastic about the contents, she asked if she could forward this to the publisher, and a quote ended up in the paper copy.
3 of 3 people found the following review helpful
4.0 out of 5 stars A good book for begginers and have nice tips for experienced developers 2 April 2016
By Nelson - Published on Amazon.com
Format: Kindle Edition Verified Purchase
I found it really useful for begginers although it contains nice tips and advices for experienced developers that come from a static typed language to Ruby (at least for me). The book is too verbose and the author sometimes takes too long to explain her point in chapter. It's very important to say that the author enforces how bad design can make you throw your company's money and this mindset is really useful in a startup environment.

I don't agree with some code changes did during the book, for example, I don't like to use hashes as constructors (maybe because I'm new to Ruby), but, I didn't see anything critical or bad designed.

The emphasis on messages rather than classes, objects and interfaces although it may confuse begginers it fits perfectly to Ruby.

The last part about tests can be used as a nice introduction to tests with Ruby since it covers most of the harder topics in tests and TDD.

I'd recommend this book for begginers and for experienced devs that have some spare money and are willing to read an easy book about design basics.
1 of 1 people found the following review helpful
5.0 out of 5 stars THE Object-Oriented Guide for Any OOP Language... 5 October 2016
By Unix Lists - Published on Amazon.com
Format: Kindle Edition Verified Purchase
While the industry moves more towards Functional Programming Paradigms and away from Object-Oriented Thinking, Sandi Metz's book, Practical Object-Oriented Design in Ruby, published in 2012, still stands the test of time with OOP best-practices. It is truly a practitioner's guide to Navigating Changing Requirements and being truly Agile.

The book addresses OOP Anti-patterns and the Reader is taken through iterative steps in evolving the Example Applications throughout the chapters. In some ways, it can be likened to thinking in more of a 'Data-Modeling' Manner, though adapted for OOP instead of Relational Databases.

If you work in Software, you should read or re-read this book. The author also has a more recent book available through her web site, which is of similar quality though has more of a Programming or Puzzle-like Feel.
2 of 2 people found the following review helpful
5.0 out of 5 stars Very good book on practical design 21 March 2013
By MartinB - Published on Amazon.com
Format: Paperback Verified Purchase
I read this book after hearing the author talk on a "Ruby Rogues" podcast a few months ago. It was apparent that the attendees were all quite impressed by Sandi Metz's book and they all recommended it. I bought the book based on this recommendation, read it and I have to admit that I thoroughly enjoyed it. The book focuses on the "art" of design in the Ruby world. That being said, the concepts, ideas and techniques describe in this book can be applied to most dynamically typed languages.

What was most interesting (and something you don't see in a lot of software book) was how Sandi describes how a senior software designer will make decisions, while considering the technical debt that comes with those decisions. I have been working in software for over 20 years and this is what I find is missing when it comes to a lot of books out there. There's the idealized view of what software is, and then there's reality. In "real life", you have a limited amount of time to do your job and you only have a portion of the real system requirements. The question is how do you create your software so that future refactoring will be easy... this is what design is all about. The best way to make sure your software is refactorable is through the "micro" level design decisions you make, it's by making sure that you have single responsibility classes, it's by reducing coupling, etc. (I don't know of any good software that came out of an ivory tower architecture, good architectures that I have seen usually migrate from bottom-up).

This book is bang on with regards to this. It goes over the "micro" level design decisions that you have to make. It gives practical tips on how and why you would make these decisions.

There's also a very good chapter on testing, which explains some of the problems you'll find testing with dynamic languages. I especially like the way Sandi describe the "false positive" that can happen in the BDD and TDD worlds. It's made very clear and I like the solution that she describes to this problem.

In the last couple of years, I have read a number of books on Ruby and Rails. There's two that stand out... Eloquent Ruby and this one. I would recommend this book to anybody starting out in Ruby (junior or senior).

One caveat though... The ideas described in this book can be applied to most dynamic languages but some of the concepts might be counterintuitive if you come from a statically typed language. (For example, the use of duck types is not something you see in Java for example. In static (compiled) languages, you are trained to extract interfaces and to make things as strongly types as possible. This doesn't make sense with dynamic languages).

In any case, I highly recommend the book.
1 of 1 people found the following review helpful
5.0 out of 5 stars A Wonderful Addition To The Bookshelf 3 March 2016
By A. Gooch - Published on Amazon.com
Format: Kindle Edition Verified Purchase
This is a great, well rounded book on object oriented principles using the Ruby language. It is now one of my favorite programming books that I will recommend to any that wish to master their craft of software development.
click to open popover