Service-Oriented Design with Ruby and Rails [Brossura]

I'm a little tired right now to give a thorough review, but I wanted to get something down to benefit other potential buyers. First off, let me give some background on myself so you have a point of reference. I've been programming web software and services as a hobby for the last 10 years. My forte has always been with Perl, with a recent desire to try newer languages like Python and Ruby. My particular interest in this book stems from a new project I'm working on that lends itself to a service-oriented design from the get-go. I have no other experience with Ruby or Rails except for short periods of "play time" with Rails when it first became popular, years ago. But I'm *very* experienced with service-oriented and scalable internet architectures (I work for OmniTI), so I expected much of the book to be a rehash of what I'm exposed to on a daily basis anyways.

The author (Paul Dix) immediately throws the reader into a sample web service, typical to any modern REST web application. What I really appreciated was how he stressed the test-driven development approach via rspec, although it might have been beneficial to give a bit more background into the advantages of TDD and the specifics of rspec within Ruby and Rails testing. Nevertheless there is sufficient coverage of the process to get the reader off on the right foot. There are a few bugs in the included code examples that have either been fixed in the github repository ([...]).

Chapter 2 describes the philosophies and methodologies behind service-oriented designs and the differentiators to SOA, XML-RPC and related books such as "RESTful Web Services". Paul makes a sane argument for service-oriented designs with Ruby over the monolithic Rails applications we've seen as Rails has continued to grow in popularity, introduced to larger production loads. The reader learns about isolating services and the benefits (testing, resiliency, performance) associated with various levels of separation.

Chapter 3 gives experienced Rails developers an example migration by segmenting a "typical" Rails installation into independent services. This had limited value to me, since I plan to write Ruby web applications from scratch. But there is still value in a series of well-presented diagrams demonstrating the MVC equivalence of service-oriented design.

Chapter 4 (along with the "RESTful Primer" appendix) provide an excellent overview of RESTful web services and API design. As there is no formal REST specification, much of this is based on accepted industry practices, but the coverage is thorough and very digestible.

This is all I have time to write up at the moment. Suffice it to say I'm very pleased with this book and will continue to refer back to it as I develop in Ruby. Although the book is designed for experienced Rails programmers, I have no reservation in suggesting this to beginner Ruby/web developers... so long as they have another core Ruby reference at their disposal.

I never review books on Amazon. But I wrote a review for Metaprogramming Ruby (Feb 2010 Pragmatic Programmers) because it was just such a must-read. And I'm writing one for this, because it's also a must-read. The target audience for this book is the intermediate Rails developer who has his all-in-one app with background processing, and is wondering "what next"? "What if tomorrow users start joining my site by the droves?" "What if I'm written up on TC / Digg / Slashdotted tomorrow?"

If I HAD to give criticism, the only thing I could think of is that this book goes into implementation details for some subjects but not others. For example, it has pages and pages of code to illustrate how to write a service in rails, Sinatra, Rack, but skips over a lot of ops related stuff. If you were going about implementing the ideas in this book, those issues would confront you far before you write your services, do your load balancing and edge caching, etc. I would love for Dix to write a second book on that topic. That's just nitpicking, though - part of the reason I think Dix went into depth with the code goes back to the target audience: it is very helpful to show Sinatra and Rack analogues to a guy who has only used Rails.

It's rare that I read a ruby book these days and learn something new in every chapter, but I did from this book. The title doesn't do the book justice. The ruby examples use Rack, Sinatra and Rails (including Rails 3 examples) to demonstrate how to quickly build and test REST services and service clients.

It covers everything from high-level architecture decisions, like when to introduce services and how to decide what goes where, to seemingly small details, like dealing with serving pagination links in apis.

The only downside is that it could have gone into more detail about how to run apps with multiple services locally.

I read it cover to cover, and frequently refer to it. I highly recommend it to anyone working on moderate to large Rails apps. It completely demystified SOA for me.