Refactoring to Patterns (Addison-Wesley Signature Series) and over one million other books are available for Amazon Kindle. Learn more
CDN$ 44.72
  • List Price: CDN$ 70.99
  • You Save: CDN$ 26.27 (37%)
Usually ships within 1 to 3 weeks.
Ships from and sold by Amazon.ca.
Gift-wrap available.
Quantity:1
Add to Cart
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Refactoring to Patterns Hardcover – Aug 5 2004


Amazon Price New from Used from
Kindle Edition
"Please retry"
Hardcover
"Please retry"
CDN$ 44.72
CDN$ 41.00 CDN$ 28.95

Join Amazon Student in Canada



Frequently Bought Together

Refactoring to Patterns + Working Effectively with Legacy Code + Refactoring: Improving the Design of Existing Code
Price For All Three: CDN$ 130.38

Some of these items ship sooner than the others. Show details

  • Usually ships within 1 to 3 weeks.
    Ships from and sold by Amazon.ca.
    FREE Shipping. Details

  • Working Effectively with Legacy Code CDN$ 42.83

    In Stock.
    Ships from and sold by Amazon.ca.
    FREE Shipping. Details

  • Refactoring: Improving the Design of Existing Code CDN$ 42.83

    Usually ships within 3 to 5 weeks.
    Ships from and sold by Amazon.ca.
    FREE Shipping. Details


Customers Who Bought This Item Also Bought

NO_CONTENT_IN_FEATURE

Product Details

  • Hardcover: 400 pages
  • Publisher: Addison-Wesley Professional; 1 edition (Aug. 5 2004)
  • Language: English
  • ISBN-10: 0321213351
  • ISBN-13: 978-0321213358
  • Product Dimensions: 24 x 18 x 3 cm
  • Shipping Weight: 980 g
  • Average Customer Review: 5.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: #68,308 in Books (See Top 100 in Books)
  • See Complete Table of Contents


What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

5.0 out of 5 stars
5 star
1
4 star
0
3 star
0
2 star
0
1 star
0
See the customer review
Share your thoughts with other customers

Most helpful customer reviews

6 of 6 people found the following review helpful By Nicholas Roeder on June 25 2005
Format: Hardcover
This is probably the best technical book I read that was published in 2004. If you are struggling to see how you can apply patterns in your day-to-day work, this book will help.
Most development work is done with existing code bases. It is less likely that you will have a chance to design something from scratch using design patterns that you are aware of. So this book helps you move toward a code base that is better designed in refactorings that lead to common design patterns.
The author suggests that many systems are now "over-engineered" due to the popularity of design patterns. I have not had the opportunity to work on such a system, but the book was still very relevant.
The code examples are actually very realistic and detailed, which I appreciated. Some readers may find them too complex and distracting from the refactoring steps, but I thought they strengthened the book.
I read the book in the order suggested by the author to those who want to study the patterns. It worked very well and the code examples carried thoughtfully from one refactoring to the next.
Examples are in Java but if you are using any OO language you will likely be able to follow them.
Many technical books are filled with typos and grammatical errors. This book was obviously well edited and not rushed out the door to publish.
Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 54 reviews
77 of 81 people found the following review helpful
A book I've been waiting for Sept. 5 2004
By wiredweird - Published on Amazon.com
Format: Hardcover Verified Purchase
Kerievsky has done it. He has started to pull together anti-patterns (a.k.a. "bad smells"), refactorings, and patterns into one unified study. All three work well individually. Together, they make a powerful combination.

This isn't as rigorously analytic as the original Design Patterns book. I fully expect more theory-oriented writers to follow the trail blazed here. Instead, Kerievsky gives worked examples, in great detail. At every point, he starts with a code sample drawn from real life, complex enough to be interesting. Then, step by step, he shows the incremental changes made to transition from it's problematic start to its pattern-based end point. Experienced programmers may find this plodding and repetitive. Beginners, however, often have a hard time planning incremental changes and executing them. The author takes care to keep the code in working order at each increment, showing a clear path through the forest of possibilities. Some readers may even trace the path backwards, giving another look at how each change moves toward the end state. The worked examples are the real strength of this text.

This is a book for the software maintainer. In other words, it addresses 90% or 99% of the work that real programmers do. Just about every other software text on the market assumes that the project just started - the disks are empty and the compiler shrink-wrap is on the floor. I admit, that kind of programming is the most fun. It's just not realistic, though. Most work is rework, the kind demonstrated here.

Another great feature of this book is what it lacks: dogmatic harangues about methodology. It even keeps a skeptical attitude towards patterns, since heavyweight design techniques aren't always right for lightweight problems. Kerievsky mentions agile-ism, but doesn't make it a part of the process. He does, however, take the continuous testing idea from the eXtremists and work that into the demonstrations. Bravo! Hardware designers may wonder what the fuss is about, since thorough testing has been part of their culture for years. It's a happy novelty in much of the software world, though, and deserves to become standard practice.

My only problem with this book is that there isn't more of it. For example, constructor chaining is a great idea. There are two kind of chain, though. He shows the increasing parameter list, where simpler constructors supply default values for the more ones with more parameters. It's also possible to chain in decreasing order, where each constructor processes one parameter and passes on the simplified list. (What's good for constructors, of course, is also good for other collections of related methods.)

The book's ideal reader understands an OO language, uses subclassing regularly, and knows something about design patterns. That reader, with enough patience to follow the examples, will learn a lot. More experienced developers won't need the step by step approach, but may benefit from seeing multiple refactorings working together to solve a complex problem. It has my highest recommendation for any developer who really thinks about design and redesign.

//wiredweird
46 of 49 people found the following review helpful
Wonderful! Brings patterns into coding, not just designing Sept. 19 2004
By Michael Cohn - Published on Amazon.com
Format: Hardcover
Based on its title alone I had high expectations for this book. It didn't disappoint. The book takes two of the most important advances of the past decade (patterns and refactoring) and puts them together into a whole that is definitely more than the sum of its parts.

I've read many good patterns books and have been applying patterns to how I think and talk about software since the original "Design Patterns" book in 1995. However, something was always missing. Through my consulting work, whenever I introduced patterns to a new team they would take quickly to the idea and patterns would become part of how they thought-but only when designing, not when coding. Since we spent more time coding than designing, patterns played less of a role than they could have.

This book does an excellent job of bringing patterns into coding, rather than relegating them just to design discussions. As the author points out, "patterns are best viewed in the light of refactoring and that they are destinations best reached by applying sequences of low-level refactorings."

This book has earned a permanent place on my bookshelf. That is, when it's not open beside me as I program. Very highly recommended!
58 of 65 people found the following review helpful
Over-complicated examples ruin a superb piece of work. Nov. 7 2004
By Cybergeek - Published on Amazon.com
Format: Hardcover
This book is the only one of its kind that tries to use a patterns approach to refactoring. It is a good add-on to Martin Fowler's book. It's a very valuable contribution to the refactoring community. Kerievsky has a no-nonsense, down-to-earth approach to the subject of Patterns. However unlike Fowler who makes an effort to keep the code examples in his book as simple as possible, Kerievsky has made his examples over-complicated with all kinds of detailed finance domain references and the XML DOM. The example he uses to show how the Builder pattern simplifies creation of Composites is like a really heavy chapter on XML processing/generation.

The "Replace Conditional Logic with Strategy" is like a chapter on Investments / Loans. It really distracts the reader's attention from the pattern or refactoring.

This is a shame because it is impossible to write a good book on refactoring without nice examples. It is also a bit surprising that none of the other Amazon reviews mention this issue.
19 of 20 people found the following review helpful
A remarkable work, with genuine wisdom and solid pragmatism Aug. 24 2004
By John Tangney - Published on Amazon.com
Format: Hardcover
This book goes much further than Martin Fowler's seminal work on refactoring. Indeed, it goes further than the GoF's canonical work on patterns. By combining the two, Kerievsky breaks new ground.

The refactorings are accessible and beautifully presented. As with the GoF book, a lot of the rationale will ring a bell. "Gee, I've seen this before..." The value of these refactorings lie precisely in that corner, where the mechanics of refactoring with a GoF pattern as the goal allow one to improve the readability and maintainability of the code.

Some of the refactorings were less than obvious to me until I read this book. And that's where Kerievsky's mastery shows. He presents fresh ideas (to me, anyway) with solid examples, and thoroughly thought-out steps.

The examples deserve special mention. How many times have you read a "manual" or other technical how-to with toy examples that fail to illustrate the point? Or with examples so narrow that they hardly approach your real-world situation. (I could name names... ;->) OTOH, how many examples are so long and laborious, that gleaning any useful information requires learning the author's example-problem domain before you can get anywhere?

Kerievsky walks the tightrope between toy examples and over-engineered examples with tremendous skill. They're Goldilocks examples: Neither too big, nor too small, his examples are juuust right.

Another area in which some tightrope walking is required is presenting material that's suitable for a tutorial, vs. material that makes for easy access as a reference. Josh somehow manages to balance the two. Reading from begining to end, one is able to appreciate the tutorial nature of the material. However, (like Fowler's Refactoring) easy look-up is made possible by the formal presentation of each refactoring.

I heartily recommend this book to anyone who cares about Software Craftsmanship (my plug for Pete McBreen's book too!)

Disclaimer: This review is based on a prepublication manuscript.
14 of 14 people found the following review helpful
Could have been a 5! Oct. 5 2005
By Dennis Becton - Published on Amazon.com
Format: Hardcover
The book is great, and I've learned a lot from it. I REALLY wanted to give it 5 stars, but the lack of full source code for the examples, detailing before and after application of the refactoring techniques, forced me to give it a 3. Ended up spending way too much time trying to piece together the snippets of code in order to fully understand what was going on.

Product Images from Customers

Search


Feedback