Though it’s safe to say you shouldn’t judge a book by it’s cover, the first 50 pages or so should give you a sufficient feel for what to expect in the rest of the book. At least that is the assumption I am making in this first look at Enterprise Integration with Ruby, a beta book currently being offered by The Pragmatic Programmers.
Just digging into the first few chapters, I’m already impressed. Immediately the reader is greeted with the standard quarky (if a bit dry) imaginary scenario to progress through the book with. The example in this case is PragBouqet, a flower shop. Though it would be wonderful to see a book that did not use some sort of E-Commerce as it’s example, this does provide a solid base for clear use cases and sample applications.
The book’s main feature as far as I can tell is the sizeable amount of code examples that fill it’s pages. The user is not given excruciating detail about what each and every line does, but is given a really wonderful description of the problem, and why it’s being solved the particular way it’s being solved.
The author takes an iterative approach, which is common in most Pragmatic titles. However, instead of being a little overwhelmed by wild refactoring at the large scale, Enterprise Integration seems to chisel off smaller chunks at a time. Though the book is intended for experienced developers, this approach is without a doubt favorable for lowering the learning curve.
The narrative approach and the copious amount of output make this book readable even without an irb prompt open. The examples are clear enough where you can get a qualitative feel for them without burning too many brain cells.
The only drawbacks of this approach is that it makes using the book as a reference a bit more complicated. Though the chapters are modular, the example spans across them and if you like to jump in midstream, this might complicate things a bit. Also, the examples are fairly specific to their domain, which means you’ll probably need to read through the example and a bit of the chapter before fully getting a feel for what is going on.
That having been said, one of the unexpected gems of this book is it’s wonderful chapter on ActiveRecord. Most other publications regarding ActiveRecord, whether online or in print, spend a ton of time talking about integrating it with Rails. Of course, this makes sense for that problem domain, but if you’re trying to get a wholistic feel for what ActiveRecord can do for you as an ORM rather than a support library to Rails. , good qualitative sources are hard to find. Of course, Agile Web Development with Rails provides a great reference for this, but if you were left scratching your head a bit… Enterprise Integration with Ruby might provide a good way to fill in the gap.
Of course, there are some of the annoying issues that are to be expected in beta books, such as code abruptly spanning pages and other minor formatting isssues, though these are minimal enough where they do not effect your experience enough for it to matter.
There is also a wonderful quotable phrase in the book:
Don’t like the sunflowers? Destroy ‘em!
Any book that tells me I can destroy wildlife if it doesn’t fit my fancy is a good book to me!
So that’s my impression after 50 pages, what’s yours?