Customer Reviews

Ruby on Rails Enterprise Application Development: Plan, Program, Extend: Building a complete Ruby on Rails business application from start to finish

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

 

 

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.

Ruby on Rails Enterprise Application Development by Elliot Smith and Rob Nichols targets a new niche in the Rails world of published books. Its goal is to connect all of the dots that make up typical Rails development for developers who have been through the tutorials, but wonder what do I do next?'

The focus of this book is breadth and not depth. The authors do a good job of balancing the explanation of essential Rails concepts while letting the reader know when they are approaching a more advanced topic that won't be covered in depth.

Throughout the book the authors follow a fictional, yet realistic scenario in which Rory the IT guy implements a simple web-based contacts management application. Each chapter builds on the previous walking the reader through the whole process of development to production deployment.

There is no Rails development until Chapter 4, pg 91. The emphasis of the first 90 pages is understanding what Rails is and why you would use it, as well as introducing the problem scenario that will be used throughout the book. This would be a bigger turn off then it was, but the authors made up for this a little walking the reader through installing everything required for Rails development on multiple operating systems.

Rather then focus on a single platform for development or production the authors use a mixed environment of Ubuntu Linux, OSX and Windows and a cross platform Eclipse IDE. They also take the time to walk the reader through installation and setup of each platform as it pertains to Rails development.

The majority of the development in this book sticks to the functionality included in Rails itself. When it comes to core components of Rails the authors do a great job of covering them: migrations, models, validations, associations, controllers, filters, views and view helpers.

Plugins are not covered except for acts_as_attachment, which is now deprecated in favor of attachment_fu.

The only issue I had with the book was with the sections on testing. The authors cover unit and functional testing with the built-in Rails testing framework. Unfortunately, the example tests are horrible and should not appear in production quality code. The sections on testing should only be used to understand how the built-in testing framework works in Rails and not as an example for writing tests. It is too bad that the authors didn't cover integration testing either.

A good thing that did come out of the testing sections in this book is the encouragement for developers to write tests which expose bugs before fixing them. It's the only way to ensure you really fixed it.

Rails 1.2.3 is used throughout the book so any changes, improvements or deprecations in Rails 2.0 aren't covered. If the reader follows the book with Rails 1.2.3 they should have no issues walking through and developing the code themselves. If the reader follows the book with Rails 2.0 they should be aware of some of the changes, those can be found at http://weblog.rubyonrails.org/2007/12/7/rails-2-0-it-s-done

The things that stuck out to me were:

* view template file naming considerablyntions
* the verbosity of not having named routes

The authors take the time to walk the reader through setting up and using Subversion as an integral part of Rails software development. It also includes setting up and using Apache and Mongrel to serve Rails. As the book moves from development to production deployment the user is shown how to deploy automatically from Subversion to their production server using Capistrano.

There were a few minor typos and one redundant sentence on page 52. This is considerably lower than other technical books that I've read.

The only giant red sections marked in my copy are the ones on testing. Take those examples with a grain of salt.

Overall, the majority of the book is filled with good advice for novice Rails developers like, do not wait until your application is built before you create and test the production environment and involve the end users throughout the process.

If you are a novice Rails developer who understand bits and pieces of Rails this book does a good job of connecting the other dots because the authors take the time to go through the full process of development to production. On the other hand if you have a good grasp on the whole Rails development process you can skip this book.

Excellent manual which emphasizes the problem-solving process and the design / deployment issues involved in developing solutions, rather than taking a simple template or cookbook approach.

This book is not intended for users who want to develop exotic uses, nor does it require users to be familiar with more complex web-based applications. It is most valuable for the ways in which it instructs users in the planning, development, and deployment processes.

Rails is a great open-source framework, but, like almost all open-source, the documentation can be rather frustrating because it does not necessarily provide the materials a user might need. This book overcomes that shortcoming by guiding the user very clearly, and not restricting the applications.

One aspect of this manual that I like is that it can help make elearning solutions more efficient by using the Ruby on Rails web development framework. The book, which is intended for users who have a basic familiarity with the framework, and who wish to develop their own applications or enterprise solutions, contains valuable guidance and insight.