Customer Reviews

Rails AntiPatterns: Best Practice Ruby on Rails Refactoring (Addison-Wesley Professional Ruby Series)

5 star:		(5)
4 star:		(1)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

I'll be honest, prior to reading this book I was starting to lose faith in Ruby on Rails authors. As a beginner to Rails, I've read a number of books to try and make sense of all the black magic going on behind the scenes as well as how to write great code in Rails. Many of those books were either "paint by number" tutorials where you didn't really learn anything appreciable or very complete (and hard to comprehend) reference manuals for everything there is to possibly know about Rails.

I just needed a good in between book! This book not only exposes you to the Rails Way of writing code in Ruby on Rails, it also gives many of the opposing examples which I would more than likely stumble down not knowing any better.

Not only that, but this is one of the most logically organized books I have ever had the pleasure to read. Everything flows together very nicely and is very understandable for beginners let alone more advanced users.

I would recommend this book in a heart beat (and I already have... many, many times). Great job guys! I really appreciate the effort you put into writing this book! You have restored my faith in Rails authors!

This book makes a great companion to Martin Fowler's Refactoring book (or the Ruby version of it by Jay Fields). As someone who's still accumulating the theoretical 10,000 hours of experience it takes to master something (Ruby/Rails), it's nice to have guides like Chad and Tammer there to suggest improvements to my technique. Highly recommended for anyone novice or intermediate Rails developer.

While the book certainly seems geared toward the novice/intermediate Rails developer, I still loved it even after building Rails apps for several years. The advice was divided for me among three categories - stuff that I already know and do on a regular basis, stuff that I know but *don't* do as often as I should, and practices that were new to me. Admittedly, there isn't a ton of info in the book that falls into the latter category, but it is in there, and it's stuff you won't find in any other book. It would be worth reading even for just those nuggets.

What took me by surprise, though, was how much of the book reinforced concepts I was already partially familiar with but haven't been disciplined enough to practice regularly, and practices that I follow regularly but didn't fully grasp why. This book lays it all out, and with real world examples. Everything I read in the book I can apply to the projects I work on everyday. Whether you're new to Rails or an old hat, this book *will* help you write better Rails applications. Read it, think about it, and apply it.

All too often, the 'patterns' books only develop a greenfield example the 'right' way. This is hopelessly optimistic, especially if (as is the case for me) you're teaching undergraduates how to use design patterns; they're not going to get it right the first time. So *refactoring* code that has "grown bad" to use a good pattern is a much more frequently needed skill.

There are other books on refactoring for Ruby, like Martin's, but i like that this one focuses on design patterns and specifically on how to leverage Ruby's features to realize the patterns nicely.

My future coverage of design patterns in Berkeley's undergraduate software engineering class will be motivated by the examples in this book.

Every section of every chapter of this book provides practical refactoring advice, and for every section I've found myself putting the book down in order to dig into my current project and apply concepts presented.

The book covers common errors seen in all aspects of a rails project: models, controllers, views, helpers, services, routes, authentication, using third party libraries, testing, performance, scaling, deploying, and exception handling.

This is not a book for learning how to write rails applications. I believe it is a book that would be best suited to someone who has at least some previous experience with rails applications. It's very useful to have made the mistakes that are covered, to have had to fix bugs, maintain, and extend code that contains these code smells, and to have made the choices that lead to the various antipatterns described.

Without that pain, I don't think you'll get much in the way of epiphanies.

I am not a ROR expert by any stretch (I have been coding on it for about 10 months) however I was able to digest this book in about 2 hours and this few months back. The explanations are extremely clear, some of the lessons are sounds others are pretty obvious. For example I found the chapter on Views (ch. 3) and the one on Controllers (ch. 4) quite useful, while ch. from 6 to 8 not so much.

Overall a very useful book for novice, almost a must-have I would say. Not so much for more advanced programmers.

My suggestion is check the book out before you buy it.

This book rules. There are so many good suggestions and I would say almost every Rails developer has encountered these messy situations before and scratched their head wondering what the best approach is to tackling it.

The book does get a little lost at points, especially in the Controller and Views section. Walking through how to use the Clearance and Authlogic gems seemed to be a bit tangential.

All in all, well worth reading, and perfect for those who have outgrown the glut of introductory level books but are still figuring out best practices.