my dog boris

Okay, so I have to admit I am not entirely a Rails noob.  I have built a couple of applications using Rails and continue to maintain an interest in its emergence in the enterprise.  However, since Rails 2.x has come out, I’ve fallen a bit behind and needed a quick refresher.  Learning Rails, by Simon St. Laurent and Edd Dumbill seemed to be a good candidate.  It didn’t disappoint.

Learning Rails is an excellent book for quickly picking up the nuances of Rails, especially if you are looking for something that is an easy read and is based upon Rails 2.x+.  The chapters are relatively short and the authors do an excellent job of knowing how far to push a concept before deferring (referring) to alternate texts for more information.  Nonetheless, I picked up a few new tidbits along the way, including some practical suggestions for dealing with nested resources and a couple of ideas for routing.  However, make no mistake about it, this is not an advanced Rails text.  For more detail, I would look into Obie Fernandez’ excellent “Rails Way” or the myriad of books on specific topics such as AJAX, Active Record, etc.

What could have been better?  I thought the chapter on AJAX was a bit weak.  The example code didn’t seem as elegant as you may expect from a Rails purest.  Also, there was not much coverage on the concept of layouts and how the location of the various view pages relate to MVC routing, etc.  I suspect even the most inexperienced Rails developer will quickly embrace the idea of layouts and partials (which were covered to some extent in the forms section).  Finally, there was not much mention of some of the newer features such as localization (probably more of an enterprise feature anyway).

One thing the author cautioned is that the book is written from the “outside in”.  In the preface, this was clarified to mean that the approach taken in this book was to present it from more of a traditional web developer’s perspective rather than, say, an enterprise application developer’s perspective.  It was cautioned that certain readers may be turned off by this approach.  I suspect that I am likely in the category of enterprise developer since I do think in terms of MVC architectures, etc.  My background is NOT in building simple scripted PHP web apps for low budget clients.  However, I was NOT turned off by the approach.  I thought everything was explained nicely and accurately, regardless of the audience.  So for you Enterprise Java purists out there, don’t be put off by the subtitle.

This book is highly recommended for those just starting out in Rails.

I just finished reading Pro Flex on Spring by Chris Giametta (APress).  Unfortunately, I can’t bring myself to recommend it.  I really wanted to, as I am getting more into Flex and I have been a Spring evangelist since before it was called Spring.  My primary concerns center around organization and approach to the example application.  I believe these things get in the way of presenting the core concepts.

The book starts off with the obligatory chapter on RIA and introduction to Flex and Spring.   This is likely necessary to provide a context.  Chris then proceeds to spend a chapter developing a lengthy project plan for the application to be developed throughout the book.  This includes project objectives, wireframes, etc.  I didn’t mind the chapter except that I was ready to launch into construction at this point.  Hold your horses.  First there is a chapter on exploring the various tools and means for developing Flex/Spring apps.  At the end of the chapter there is a rather awkward lesson on creating 3 different Eclipse projects to hold the client, server (Spring/Hibernate), and library projects.  They are rather oddly named but that is a personal preference.  Okay now we should be ready to start.

Not quite.  There are another 6 or 7 chapters to endure first, including another introduction to Flex applications (am I supposed to be adding these snippets/examples to the projects I just created?).  The Flex deep dive gets off on some tangents that I believe would be best left for later.  For example, diving into graphic manipulation (Matrix, Graphics, etc.) and skinning at this point is a little premature.  I would have focused on the basics, perhaps demonstrating the technique of custom components by overriding a behavior or creating a component that combines a couple of UI widgets.  So I am typing along, not knowing if this stuff is going to be used down the line or not, or where the heck I should be saving it.

Next is a chapter on Spring.  Again, nothing wrong with Chris’ description.  Unfortunately, he starts creating sample applications again.  I am typing away thinking this somehow all ties together and if I quit now, I’ll only have to come back later.  I don’t have any issues with his use of Spring in the examples, it’s just hard to cover the concepts in such limited space much less try to create a sample multi-tiered application within the same chapter.  Again, I would have stuck to explaining the concepts and left the detailed code for the sample application (which I presume we will get to at some point).

Moving right along, we dive into Flex and Spring Integration Architecture.  Now we are getting somewhere.  This is probably one of the more valuable chapters in the book although I probably could have done without another example (RSS feed reader).  Chris does a good job explaining the various means for interacting with the server side.  He also includes a nice description of the Spring BlazeDS integration project designed to help simplify the configuration.  

Chris then digs into Cairngorm and PureMVC, taking the opportunity to introduce yet another sample application – the Contact Manager.  Again, I love examples.  However, trying to introduce so many unrelated sample applications throughout the book draws attention away from the overall concepts.  There is too much space wasted describing code required to make each example work.  After all, once you dive into an example application you have to provide the complete code base or that will create other frustrations.

Chapter 8 is on Data Persistence and Chris feels obligated to describe (with examples) each technology that may be used to access data (iBatis, Spring JDBC, Hibernate, Hibernate with annotations, etc).  

Chapter 9 is on Security and this was pretty nice as it focused on Flex integration with Spring Security.  However, it did not mention the Spring BlazeDS Integration project and how it helps simplify the communication between Flex and Spring Security.  Also, I don’t believe he needed to get as detailed on the implementation of the authentication example.  There are simple pre-defined beans in the Spring Security library for facilitating authorization against an in-memory or persistent user directory.  Perhaps those would have been adequate enough to explain the concepts.

In Chapter 10 we finally get around to the sample application set up in Chapter 2.  The remaining chapters deal with building out various aspects of the example, including the database model, Spring Service tier, presentation, etc.  I would say that Chris’ strength appears to be in the presentation tier with Flex/ActionScript.  I’m not crazy about some of his design patterns/strategies on the server side.  In particular, I have to admit that I never quite embraced his “object identifier” concepts and use of an “assocobjectID” field on every entity table.  It seemed obtuse and non-descriptive.  I’ve never seen this used in practice.  I much prefer for green field projects to stay with conventions such as “id” or “xxxx_id” for the primary key and “xxxx_id” for the foreign key fields in many to one relationships.  Anyway, I am picking at straws here.

The bottom line is that I am happy to start seeing books on Flex as an enterprise application technology.  Unfortunately, this one makes it a little hard to get to the meat of the content.  If you are thirsting for any content on the subject, I would pick up a copy.  However, I would focus on reading through it rather than trying to work the examples.  You may get frustrated.