Ruby on Rails Enterprise Application Development: Plan, Program, Extend [Paperback]

It's very clear from posts on the rails email list that there's space for books that take the novice developer beyond what they learn in beginners' books like Agile Web Development With Ruby on Rails. Those books will help you build your first app and get a sense of the structure of Rails but before long you'll want to write code that needs to be reusable between models, or across projects, or to interface with services other than databases. The beginners' books, by definition, don't deal with intermediate topics. That's the niche _Ruby on Rails Enterprise Application Development_ sets out to fill, but sadly it doesn't offer much beyond those beginners' guides.

Based on the title, I had expected going in that the book would be mostly focussed on cross-systems integration such as the use of LDAP, web services (particularly SOAP), connecting to multiple and/or legacy databases and other topics often lumped together as "enterprisey" which push at the rails conventions or require them to be abandoned. In fact the book would be better titled along the lines of "Up and running on Ruby on Rails in a small business" as the application developed through the course of its chapters is very simple and doesn't demonstrate much about Rails itself that couldn't be gleaned from AWDwRoR or one of its competitors.

Where some may find this book most useful is in the attention paid to windows-based development and to deployment (where it focusses on unix-based systems). Most of the books currently on the market do touch on using windows, but the authors of this one clearly use it themselves and actually advocate the use of an IDE for windows development. If your tastes run to Eclipse on Windows, that may draw you to this.

Though the book references Rails 1.2.3, the application built inside could just as easily have been built on Rails 1.1. The app is CRUD-based, but there is no mention of REST or map.resources, despite the fact that they could have simplified it. Authors don't have to buy into the prevailing wisdom in the rails community, but it's a shame when strategies that can simplify apps aren't covered.

Perhaps more worrying given that Rails 2.0 is now out the door and will be the default for anyone starting out with this book now is the use of deprecated techniques such as dynamic scaffolds (the scaffold keyword was removed 10 months ago in changeset 6306) and old-style pagination (which left in changeset 6992 back in June)

There certainly aren't as many books out there for newcomers to Rails as there are for some other languages/frameworks, so its inevitable that more are to come. It's a shame that already at least two such books have been pitched at intermediate developers rather than their more correct audience, and hopefully that trend won't continue. It would also be very helpful if packt would publish an addendum to this volume detailing the aspects that no longer work in Rails 2.0. Missing some great new feature in Edge Rails is one thing, but it's quite another to rely on features that were scheduled for removal over six months before a book goes to press.

Disclaimer: I was sent a free copy of this book to review.

"Ruby on Rails Enterprise Application Development" states that it's aimed at corporate developers who already have a rudimentary knowledge of Rails but who want to move on to building a full-scale application with a view to deployment within the enterprise. Despite this, the book still covers some of the basics like installing Rails, creating a new application, getting an IDE, installing a database engine, and so forth, although there seem to be rather random expectations that you already know certain things about Ruby further on.

An interesting concept used in this book is an underlying narrative based around a fictional company that has various problems that can be solved using Ruby on Rails. It forms the basis of a chatty, friendly, but ultimately pragmatic approach that permeates the book. The narrative also enables the authors to guide readers through an "enterprise" problem in the way that developers at such an enterprise would approach it, which takes the book far out of the realm of dry, reference material, and into practical, hand-held, tutorial land.

In short, I really like this book and I think it's an excellent place for developers within a corporate environment (as opposed to independent developers) to start. Unfortunately, however, it also suffers from the breakneck speed that Rails is advancing at, as it squarely focuses on techniques used with the Rails 1.0.x, 1.1.x and 1.2.x revisions, with no coverage of formats, REST, and all the various Rails 2.0 goodies. I don't consider this a major failing, however, as this is a great book to bridge the gaping chasm between, say, Agile Web Development with Rails and The Rails Way, and it is perfectly tailored to its market.

Book Review: Ruby on Rails Enterprise Application Development

"Building a complete RoR business application from start to finish" is the tagline of the book, and I commend the authors for living up to it.
This book is a very well written introduction to building a complete application, with enough emphasis on all aspects of the application development, starting with requirements gathering, design, development (in a team setting), testing, deployment and tackling post-deployment issues. The narrative flows very smoothly, expounding various techniques as they come along in a very natural, need based manner and keeps the reader engaged in what the task is at hand and how it will progress.

The book has ten chapters, all but the first are devoted to developing a very simple application to publish a list of sales contacts. I liked the fact that the application itself is extremely simple and does not need any deep knowledge of a specific domain.It stays out of the way, and that keeps the development process focused on Rails and not on the application itself. In real world, though, we would want the opposite, that Rails stays out of the way and the application domain be the focus. But, this book is about Rails.

Chapters 2 & 3 are devoted to stating the problem, designing the solution and laying foundations of the development process. A brief but sufficient introduction to installing the rails stack (Ruby, Rails, Mongrel, MySql, ssh) on various platforms, setting up the IDE (Eclipse), source code management using Subversion (so that a team can develop without loosing track of the code changes), takes up the bulk of the 3rd chapter. Within the limitations of space, the authors have done a good job of describing the steps and pointed to more in depth resources where needed.

Chapters 4 & 5 talk about developing the core application, with some material cleverly tucked away for "future enhancements" in later chapters. All the basic aspects of Rails framework are introduced in these two chapters with clear and concise description of each layer of the MVC architecture.

Chapter 6 jumps "Into Production". I have liked this approach and whole heartedly agree with the authors when they recommend: "Do not wait until your application is built before you create and test the production environment.". Again, they have done a good job of touching each aspect of "productionizing" their application, however brief it may be so that the reader is made aware of the gamut of things that need to be taken care.

Chapter 7 & 8 revisit the application and demonstrate how to improve the user experience (via Ajax) and extend the application after gathering important user feedback. Although adding search facility, task tracking and file upload seems to be a logical way to extend the app, I was surprised to see something as basic as user authentication got pushed in this phase. I would have expected it to be covered in the "core application" section. But that may be just my opinion, biased by the way I have been developing applications.

Chapter 9 deals with advanced deployment using capistrano and post-deployment tuning and optimization. About 68 pages of information packed with various techniques. This was one chapter I learnt the most from, since at my place of work, I do not get to deal with it as much as our deployment team does. By the same token, I cannot speak about the accuracy of the information presented, but based on my experience from the previous chapters, I trust that the authors have done due diligence and paid attention to details.

Chapter 10 was perhaps the only chapter which I felt a bit fluffy and could have been used to cover some more technical stuff. But it was short and I would excuse the authors for wrapping up by philosophizing a bit :-)

The only Appendix to the book described how to set up your own gem server. I had expected an Appendix on the more current features (like RESTful resources), without which the book looks dated already. But Rails is a fast moving target.

Overall, I enjoyed the book, and would heartily recommend it to any novice who has dabbled with Ruby and Rails and now wants to get serious about it. I was also happy with the publication quality. The cover is attractive, fonts are good, the layout pleasant (other than the TOC which appeared a bit crowded) and readable, good quality binding, and not many typos along the way. Kudos to the authors and the team for a job well done.

DISCLAIMER: I had received a free copy of the book for review.