Refactoring: Ruby Edition

Refactoring Ruby Edition Programmers can transform even the most chaotic software into well designed systems that are far easier to evolve and maintain What s they can do it through a series of simple proven steps This boo

  • Title: Refactoring: Ruby Edition
  • Author: Jay Fields Shane Harvie Martin Fowler
  • ISBN: 9780321603500
  • Page: 298
  • Format: Hardcover
  • Programmers can transform even the most chaotic software into well designed systems that are far easier to evolve and maintain What s , they can do it through a series of simple, proven steps This book features Ruby examples and idioms throughout not code adapted from Java or any other environment.

    One thought on “Refactoring: Ruby Edition”

    1. There's some good stuff and some not so good stuff in here.The discussion about the refactoring principles and process are excellent. It ties in well with the explicit mechanics of the refactoring, which is about being able to take small, behaviour-preserving steps.Some of the examples are suspect though. The authors point out that the refactorings are not designed to demonstrate a business model, but some of the use of Mountain Bike classes just seem way off. Also, while they don't fully factor [...]

    2. Nothing revolutionary to any experienced programmer, but a nice confirmation of how to do refactoring Ruby style.It's a great book to have in the office for starting discussions about how a piece of code should look.I flew through the first 100 or so pages, but the catalogue of patterns stopped me dead. That section of the book deserves to be read in small chunks as you find offending code in your own codebase.I read the original version in Java but I feel like I got more out of the Ruby version [...]

    3. A must read for any Ruby developer who isn't familiar with the specifics of refactoring. If you've heard of refactoring and think you're doing it when you move code around, you're probably doing some variation of the specific refactorings discussed in this book. You need to read this book to better understand the various kinds of refactoring that you can utilize to clean up your code base so that it's more readable and maintainable.

    4. Refactoring is "the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure." This is a Ruby version of the original book on Refactoring. It's basically the same thing using Ruby instead of Java, with a couple of new refactorings specific to Ruby. I love this books emphasis on quality design through tiny changes, as well as its reversal of the traditional design-code-test to test-code-design. Not only is it [...]

    5. This could do with a second edition, but don't let that put you off! The foundation of Martin Fowler's original makes this book an important one. If you're working with Ruby or another dynamic language (rather than Java) then it's worth having the examples in Ruby and the relevant extra refactorings. Pick up this book to learn about refactoring (not the details of Ruby syntax) and you won't be disappointed.

    6. Excellent introduction to the discipline of refactoring. You'll see these lessons reappear everywhere both in your code and in other learning materials. Part of the canon of programming (and now without all the Java!)Favorite quote: How will you know when you are really getting it? When you start to calm down. When you feel absolute confidence that no matter how screwed-up someone left it, you can make the code better, enough better to keep making progress.

    7. Must read for ruby developersBest quote:You are likely to see new possibilities in your code, even if you have worked with it for years, once you know about the smells and the refactorings that can sterilize them. You may even want to jump in and clean up every problem in sight. Don't. No manager wants to hear the team say it has to stop for three months to clean up the mess it has created. And, well, they shouldn't. A big refactoring is a recipe for disaster.

    8. Good material and remains useful as a reference, but I take issue with the style of presenting each refactoring. It's effectively backwards, with a concluding recap first (minus any context), then paragraphs of detail, then an introduction to each refactoring. Very strange, but it can be parsed easily I guess.

    9. Much of the ideas told in this book are known from the Clean Code. But there was still many other valuable hints for use. And yes I would use this book as a reference too. Just put onto the valuable list of books.

    10. About 80% of the book is about refactoring strategies you will already know if you've been programming for more than a year (though you will not have explicit names for the strategies). So, only about 20% of the book is useful for intermediate/experienced programmers.

    11. I bought the hardcover years ago and gave it away. Reading this 5 years after it was written feels strange. All examples are not perfect. Better but not ideal.

    Leave a Reply

    Your email address will not be published. Required fields are marked *