Advanced Rails

• #11 in Best Ruby Books

9 Reviews

Sort by: Most Helpful ▲ Date Rating

I've been developing in ruby for a few years, and rails seriously for less than a year, but reading voraciously, and I own a couple dozen ruby and rails books (including outdated 1st editions). THis one is unique, it's a smallish (325 pages)packed with info that other books deemed too hard to explain or inessential for beginners. Some of the chapters are too much information for me (especially i18n, UTF-8 and localization) but that's because of the nature of my work. The chapters on metaprogramming/ rails coding techniques, database usage, profiling, performance tuning, security and are truly outstanding.

Like i said for Scott Raymond's Ajax on rails, this author is a technical master and an excellent communicator. The explanations are efficient, and move right along. The english is tight and typo-free, illustrations, screen shots and code snippets are all useful. There are techniques discussed here, such as using MQ (or git-add) in conjunction with benchmarking/profiling, that I would say if you don't know them, your rails development team simply will not be competitive, and make no mistake, this has become a very competitive market. I would recommend that every rail dev read this cover to cover.

This is now one of my 4 favorite ruby/rails books (the others: "Rails Way", Black's "Ruby for Rails", and "Ajax on Rails")

What's not in the book: domain modeling, UML, denormalization, those kinds of topics. It's not a data modelling/ activeRecord book. Ajax (pretty well covered in other books), except as it relates to performance and security.

Nitpicks: it's not quite perfect,:

- mercurial coverage: i would prefer git and darcs coverage, or at least a mention. The CVS discussion is superfluous, also.

- weak index: on a few occasions, space is devoted to configuring apache (p. 106, 136). Do they show up in the index under Apache? Also nginx only rates a mention as the leading reverse proxy. There's an index entry for "code"(?!). Not indexed: facets, evil (p 45), money gem (p. 224), ... This is an extremely important (time-saving) thing, I would be willing to pay 3x the price for a well-indexed book.

- search engines (p 169) I wouldn't concede ferret is industry leader, he should have mentioned the SOLR and sphinx plugins
- the bit about PHP security, p 131 seems irrelevant.
- some other points could have been footnoted: class variables and inheritance in 1.9 is still being debated by the ruby core team (p 20) and plugin load order is also under debate (p 75).

As Ruby on Rails rocketed into the development community's hearts and minds a few years ago, the number of books on the subject climbed with it. However, a lot of these books were introductory in nature (Agile Web Development with Rails, Beginning Rails, Build Your Own Rails Applications, etc.). What's a budding Rails-head to do once they've gotten the basics down? Books like Advanced Rails -- which was released late last year by O'Reilly - aim to fill this void.

Author Brad Ediger has been kicking around the Rails scene since the pre-1.0 days. Though not a Rails "luminary" necessarily, he certainly qualifies as an advanced user. He is CTO for a Real Estate tech company called Tasman Labs and runs a web design (and Rails consulting) firm called Madriska Media Group. He seems like a sharp cookie and a decent writer.

Advanced Rails covers quite a bit of territory, going for breadth rather than depth most of the time. Each chapter covers a classic, pivotal development concern... well, at least most of them do. The chapters are as follows:

1. Foundational Techniques
2. ActiveSupport and RailTies
3. Rails Plugins
4. Database
5. Security
6. Performance
7. REST, Resources, and Web Services
8. i18n and L10n
9. Incorporating and Extending Rails
10. Large Projects

By "Foundational Techniques", Ediger is referring to Ruby and Rails techniques, principals and patterns like Metaprogramming, Don't Repeat Yourself, and Functional Programming techniques. The chapter also goes into a fair amount detail about the Object/Class/Module relationship. A bunch of this may not be particularly new material for most Rails users who've been at it for at least a few months. However, it's still nice to have all this stuff in one forty page chapter... good to have handy to refer to. Also, there are some nice nuggets in there that could save you some head-scratching. For example, what's the difference between Kernel#lambda and Proc.new? The answer is that, if you *return* a value from the block passed to Proc.new, the calling method is exited as well, abandoning any code that you might have after it.

If the first chapter feels like it's leaning towards a reference work, the second chapter -- which digs into all the goodies offered by ActiveSupport and RailTies -- pretty much falls over right into reference-land, complete with a method-by-method listing of features added to standard library classes. This may seem even more like just putting api docs available online into print, but Eidger defintely adds a bit more explanation. And, I haven't really seen anyone give a rundown of just what the heck RailTies does. That's the library that provides the glue to pull together the more famous Rails libraries to make it all work together as rails: generators, initializers, etc. There is definitely some interesting and not necessarily readily available information here.

Chapter three covers Rails Plugins, and is quick and painless. It explains the common files and directory structure in a plugin and talks about how Rails loads them. It also talks about using Piston instead of svn:externals to manage plugins and show some example plugins.

The following three chapters cover more of the classic eternal problems faced in running high-traffic sites: databases, security, and performance. These really make the most sense in an "advanced" book; they are the "brass tacks" that everyone must get down too if they go beyond the "toy app" stage. Ediger talks about the strengths and weaknesses of the various popular database systems. He also goes into the benefits of using the filesystem to store data, which is largely because web servers can make use of fast system calls to dump files straight into the TCP socket. He also covers some advanced db features like composite keys, stored procedures and clustering.

The security chapter isn't all that long and a lot of the info it covers can be found in beginner Rails books... SQL injection, cross-site scripting etc. However, the book would be remiss to not include this material and it is presented in a concise and complete manner. This would be good to refer back to now and then to make sure you haven't slipped in your security awareness. Ediger also doesn't hesitate to make specific recommendations, like "whitelist rather than blacklist".

He also jumps right into recommendations while writing about performance optimization in the next chapter: "Algorithmic improvements always beat code tweaks", "As a general rule, maintainability beats performance", "Only optimize what matters", "Measure twice, cut once". He then goes on to cover specific tools and techniques for uncovering your bottlenecks, from a quick explanation of basic statistics to using httpperf, benchmark, and Rails Analyzer Tools, improving database calls (using indexes and "include" on finders), and the various caching solutions. There is plenty of good information in this chapter; also a good bit of reference next time you need to track down a logjam.

Chapter seven covers RESTful Rails, from the very basic theory as outlined by Roy Fielding to exactly how Rails has chosen to use these concepts, and is the longest chapter in the book. The amount of coverage REST gets seems questionable since Rails has been very heavily into the RESTful approach for over a year and embraced the philosophy so thoroughly that it's hard to imagine anyone using Rails today without being exposed to the concepts.

On the other hand, one can still wire up verb-oriented actions in routes.rb and might be able to get away with ignoring all the RESTful goodness. So maybe there are some out there that can benefit from this chapter. Plus, having such thorough, theory-to-practice coverage allows the chapter to stand on its own as a solid reference to the whys and hows of RESTful Rails. It also has one of the better sections on RESTful routing that I have seen (routes being one of the more mysterious and sometimes frustrating pieces of Rails).

Rails has gotten plenty of grief for its lack of official support for Internationalization and Localization, but in Chapter eight, Ediger lays out the options, such as gettext, Gibberish, and Globalize. He is most enthusiastic about this last library and it does appear to be quite powerful, including support for translating strings, translating model fields, localizing numbers and dates, and even recording what needs to be translated by saving them in the database. Creating multi-lingual websites is a hard problem in any web-development framework and most other frameworks have plenty of head start. However, Ruby and Rails certainly isn't without options and it will only get better.

The next to last chapter of Advanced Rails runs through a number of alternatives to the standard components of the Rails framework. On the database end, it covers DataMapper, Ambition, and Og, giving this last one the most attention. For alternatives to ERB templates, Ediger talks about Markaby, Liquid and Haml, all in a very brisk fashion. He also talks about using traditional Rails components -- like ActiveRecord and ActionMailer -- outside of Rails applications. The chapter closes with a discussion of how to contribute to Rails (hint: submit a patch... don't just bitch!).

The last chapter is called "Large Projects" and covers some useful information about working on a Rails project with a team, beginning with version control (though anyone who is writing code that covers more than a single file and *not* using version control is just plain insane). This starts with a quick overview of Subversion, however this feels like it is really a set up for making a case for "decentralized version control". Ediger does a good job of explaining these concepts, using Mercurial for his examples. This seems a bit unfortunate, since many people on the Rails core team have embraced Git and it is looking like Rails will eventually move its repository to Git. However, Mercurial has a reputation of being more user-friendly, so that may have influenced his decision. And it's useful information regardless.

Chapter ten continues on to discuss avoiding migration numbering collisions, issue tracking, keeping Rails and required gems within a project, web servers, load balancers, production architecture and deployment tools like Capistrano. This is all covered in a fairly quick fashion so don't expect a lot of depth.

That last sentiment came up often while reading this book. It often felt like Ediger was trying to get every possible Rails-related topic into the book that he could, but didn't want to come out with some 1000-page behemoth. Plenty of the topics mentioned don't have much more coverage than you could get with a quick "googling". However, there is something to be said for being exposed to a lot of tools, projects and concepts in one go, even if the exposure is sometimes superficial. I definitely found reading this book worthwhile and will keep it around to refer back to now and then. I don't know if I'd go so far as to label it required reading, but then again books on web frameworks rarely are.

I collect every ruby / rails book. So I purchased this book without checking the content. I read the first chapter during the weekend and found this books is really helpful. This books teaches advanced Ruby and Rails in simple and clear style. I am too eager to continue read the book, so I will stop here.

BTW, I feel the order of books a rails programmer should read is:
The Official Ruby on rails books, 2nd edition
The Official Ruby book or the Ruby way
--then do a few rails projects and continue with this book.

With 'Advanced Rails' the O'Reilly family of Rails books is looking to add a Rails book that talks about some of the extra stuff you can do with this great technology. At 300+ pages long this isn't a book with 'Learning' in the title, rather it assumes that you have some fundamental Rails knowledge and are looking to improve your skill set.

Chapter Overview:

01. Metaprogramming
02. ActiveSupport and RailTies
03. Rails Plugins
04. Database Stuff
05. Security
06. Performance
07. REST and Web Services
08. i18n and L10n
09. Incorporating and Extending Rails
10. Large Projects (Source Control and the like)

Rails is a powerful framework but it isn't an easy one to always understand and get working. If you are looking to use Rails in your web app and want to get better at understanding the ins and out of it, this book can really help fill in the blanks.

If you want to become a better Rails developer/admin pick up this book and get better immediately.

**** RECOMMENDED

For a programmer who doesn't work in an office full of rails gurus this book answers a ton of questions I would like to ask, but have no one I could ask.

Half of the book is bits of rails wisdom mixed in with recipe like code snippets.


A very timely book for me. I especially like the further reading sections at the end of each chapter. The book is new enough that all the links are current, and I have learned a few nuggets of knowledge from these as well.

The section on globalize was immediately useful on one of my current projects and returned my investment in the book many times over.

No wonder amazon only has one left today.

Although the title suggest otherwise, Advanced Rails is really required reading for anyone using Rails - beginners and gurus alike. The information provided is excellent, with essential tips and sound advice. In particular, the chapters on routing, security, internationalization and database issues are well worth the purchase price. Like Obie's The Rails Way (Addison-Wesley Professional Ruby Series), this book should live on your desk in your workspace. What's missing? Well, it would have been nice to see information on Git considering the effort put into covering source control systems. It's also surprising that there is not more on testing techniques and issues. But overall, this book is fantastic, and chocked full of juicy info you won't find in any of the other Rails books currently available.

I finished this awhile ago and while I was reading it I said to myself that I should jot down some of the good things about this book. But, like everyone else, I'm a little too busy and a little too lazy to do stuff like that.
Maybe it's just as well, since if I had, this review would probably run too long. I wasn't crazy about the first chapter on Metaprogramming, but the rest of the book more than made up for it.

I loved that, for once, a Rails book did not start out telling me how to install Rails. Ok, maybe they don't all do that, it just feels that way sometimes. Instead, by page 6 you are looking at charts on how Ruby class inheritance works.

I really enjoyed Chapter 1 "Foundation Techniques". It covers interesting topics such as "Metaprogramming Techniques" and "Functional Programming".

The other chapters weren't as interesting to me as the first, but all contained practical information that could be put to use by the working Rails Developer depending on the requirements of your specific project.

This book is almost worth it just for the first chapter's dive into Ruby metaprogramming, but the rest of the book doesn't disappoint. Ediger delivers useful advice regarding available methods, alternatives and considerations that all serious web developers should take into account.

This book should be non-optional for all Rails development teams, as it has some of the most sane and sober treatment of relevant topics I've ever read in a single book. From security to databases to deployment, this book gives the reader a solid foundation in nearly all of the major disciplines involved in building web applications.