----- 
:type: article
:permalink: the-merb-way-review
:tags:
- ruby
- book
- review
:title: "Book Review: The Merb Way"
:toc: true
:date: 2009-11-14 19:41:36.788596 +02:00
:summary: A review of "The Merb Way", by Foy Savas. This book dives deep the framework, and can be really helpful to those interested in understanding more about Merb – or about developing any modular application in Ruby.
-----

When I first picked up this book I was surprised by its length. Somehow, after reading "The Rails Way":/articles/the-rails-way-review, I got stuck in my mind that _The Merb Way_ had to be almost equally voluminous. Instead, this book is about 300 page long, roughly as long as the sum of the chapters devoted to _ActiveRecord_ in Obie Fernandez's acclaimed Rails bible.

Apparently it only takes 300 pages to describe a web framework nowadays! I couldn't help but feeling a bit skeptical at first. Even in the foreword, Obie Fernandez presents the book – and the whole "Merb":http://www.merbivore.com framework – with some initial skepticism: isn't Ruby on Rails enough? Why do we need yet another Ruby web framework? And above all, seeing that Merb is going to eventually be "merged into Rails 3":http://weblog.rubyonrails.org/2008/12/23/merb-gets-merged-into-rails-3, why on Earth do we need a book about Merb, _now_?

Needless to say, Foy Savas proved that both Merb and its book cannot be dismissed just like that.

h3. Getting started

!>/img/pictures/therailsway.jpg!

The book starts with the original "Merb Pastie":http://pastie.org/14416, a single page of Ruby code able to sort out HTTP requests, dispatch them to the appropriate controllers and render a web page. This piece of code is enough to convey what Merb is: a new breed of web framework, almost as simple as it can get but very poweful and flexible at the same time.

As you start diving in through the first chapter, you realize you're reading about a _Hacker's Web Framework_. That's precisely what Merb is: a very versatile tool to get the job done, in the simplest way possible. Similarly, _The Merb Way_ immediately feels like a _Hacker's Handbook_ rather than an ordinary guide on how to develop web applications. You won't learn what MVC is by reading this book, and don't expect to be taught what a _mixin_ is; you are reading a book about a Ruby web framework that was born after the _Rails Revolution_, so it is safe (for the author) to assume that:
* You know the Ruby programming language
* You know what Ruby on Rails is and you tried it out, at the very least

The first few chapters are about the core functionalities provided by an an MVC framework: after a comprehensive first chapter about Merb's fundamentals (from the layout of a Merb application to an overview of Merb internals) you are quite abruptly "introduced" to routing, controllers, views and models. These chapters do not aim to provide a comprehensive description of each component, they simply tell you: _here's how Merb does this_.

Out of the first five chapters, favorite is definitely the one about _Models_. Although Merb is ORM-agnostic, DataMapper is the _de facto standard_ for Merb applications, and it fully embrace the framework's design and extreme flexibility without being _in the way_ of your code.
Foy does an excellent job in this chapter by strategically describing DataMapper's code from the top to the very bottom, from the highest abstractions to raw SQL code, using a plethora of snippets taken from the actual Merb code.

h3. It's about how Merb works, not how to work with Merb

After reading the _Models_ chapter I decided to go back and re-examine the previous chapters. I didn't notice until then, but the author sneakily _smuggled_ a consistent amount of Merb source code into this book. This is rather unusual for books about web frameworks: they normally tell you how to use the framework, not how it was built! While this can be disappointing for people used to read Rails books, it came as a very pleasant surprise to me. 

About 40-50% of this entire book (and I'm not exaggerating) is Ruby source code. In a good way, it feels like a collection of strategically-positioned code snippets glued together with explanations of the most tricky bits and digressions on how the framework was _designed_. In other words, it probably contains just enough text to make sure that the average reader understands the code, but remember that the _average reader_ of this book must know Ruby failry well.

There is no pointless prose in this book, no explanations of obvious methods, no fancy words, no useless boasting on how cool the framework is: just an objective description of how Merb works and of the key design decisions behind it. If I may, the only thing that doesn't feel quite right with this book is its title: _Merb Internals_ would have been a better choice. Once you realize this, the book suddenly makes sense, and can even make you a better Ruby programmer. 

_The Merb Way_ does an excellent job in describing how to design a web framework, or any real-world Ruby application for that matter. It teaches you that modularity is the key to flexibility by showing how the Merb stack is organized. Sure, it doesn't teach you how to create a blog in five minutes, but perhaps a thorough explanation of how anthentication is implemented (Chapter 9) will actually be useful in two months time, when you'll have to create your own Merb plugin from scratch.

h3. Some constructive criticism

The idea behind this book is clever but a bit dangerous. I flipped through the pages in front of my wife and asked her what was wrong with it. _"There's too much code!"_ she said, without hesitation. Precisely.

It is damn good Ruby code, but sometimes you wish there was more text describing how to use it in practice. Or maybe some code examples on _using_ the framework on a real-world application. Not a chance. Of all that holy code, there's not much featuring something other than Merb itself. Basically the exact opposite of all the other books about Rails or other web frameworks!

Even accepting the fact that you are not reading a book about developing web applications, there are two more things which could be improved:
* Merb's design is very intriguing, and you grasp the essentials by reading this book, but a few diagrams here and there and more in-depth digressions on the subjects would have been nice.
* Besides DataMapper, what I really wanted to read about were Slices and Parts – unfortunately the chapters about them are far too short and shallow. The reasoning behind this is that _their future may be uncertain_ due to the Rails 3 merge. Pity.

h3. Conclusion

The death of Merb has been greatly exaggerated. Too bad I "gave up web frameworks altogether":/articles/take-back-your-site-with-nanoc/ for my site, because after reading this book I would have gone for Merb _today_ rather than waiting to see the wonders of Rails 3 _tomorrow_. Even a book with this title could have been written in a very different way, I would still recommend it if you want to become a better Ruby programmer by learning from the best: Merb code really stands out, even compared to Rails, and Foy Savas does a great job presenting and describing it.