Customer Reviews

Metaprogramming Ruby: Program Like the Ruby Pros

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

 

 

I've read quite a few Ruby books and this is one of the best. The author very effectively does a number of things in this book:

i) Highlights the conceptual differences between Ruby and other currently popular languages

ii) Shows how those conceptual differences are expressed in programming constructs by walking the reader through a number of small but realistic example problems

iii) Reviews internal details of a number of pieces of real-world software (most notably Rails) to show how the authors of these packages use the techniques he describes to solve their problems

iv) Provides a number of helpful and applicable guidelines on how to 'think in Ruby'

v) Generates a GoF style catalog of implementation patterns

vi) Skewers the notion that 'metaprogramming' is any different than regular programming

After finishing this book I have a real appreciation of the techniques the author describes, and how they can be used to write flexible, powerful, and maintainable software. Before reading this book I was aware of a number of these techniques, but I didn't necessarily understand how they could be effectively used to solve real problems. Now I do. The book truly covers how to think in Ruby - how to naturally solve problems in Ruby, as opposed to adapting techniques commonly used in languages from the C/C++/Java lineage.

The one major criticism I had of Metaprogramming Ruby was the 'fanboy' tone that permeates a lot of the text. Frequently the author seems more interested in getting you to agree with him that Ruby is great than in conveying the concepts being discussed. There are a lot of gratuitous slams of other languages (especially Java) that were frankly unnecessary and distracted from the book. Had the tone of those comparisons been a little more highbrow and a little less schoolyard, this would have been a better book.

Overall rating: 4.5 stars

I have a BS and MS in Computer Science, and worked with Ruby professionally for two years. I've read every major Ruby book on the market. This book brought me to the next level. If you dig Ruby or Rails and are a programmer looking for the next step, this is it.

I have been programming in Ruby for almost two years, and I have done some Ruby on Rails. With this book I finally begin to understand what Ruby was doing for me all along -- especially when it's running on Rails. Ruby was easy to use like I've used many other languages, but now I understand how unique and powerful Ruby really is. And I'm sure that I will begin to take advantage of that extra power.

Also: the book is well written and organized. I especially like that whenever a particular topic is mentioned a page reference also appears. This makes it easy to do a quick review of the topic before going further, like "Hook Methods (181)."

This book will not sit idly on my shelf. I'll be going back to it again and again for review and further mastery of the topics.

This book offers an amazing look into the beauty and power of Ruby. It has made me a better Rubyist. It is accessible and entertaining. Not only is the use of a second-person narrative throughout astonishingly well executed, but the character development is pristine as well, Bill's in particular. In the course of one week we see Bill evolve from strange, overbearing know-it-all coworker to mentor, friend, and even intrigued learner. But that's when things get interesting and take quite a turn in the story. I don't want to give anything major away but Bill sleeps with your wife at the end.

This is the first technical book I have ever read written like this. I'm a author myself and this book has changed the way I think about writing articles, white papers and books. If you are just starting out in programming ruby or are a season veteran in ruby you need to pick up this book. The way it is written it is well put together and it makes you keep wanting to read more. This is not your normal technical boring go through the motions book. It's like a technical novel that is the best way to put it, I never met the author (hope to do so in the future to thank him) but sometimes when reading books all you need is one idea or 1 chapter or even one word to change the way you look at things. Paolo creates a setting like you just was hired at a new company and on Day one they want to implement a project in ruby, so a virtual character "Bill" your mentor your programming lead helps you along the way. I loved the postit notes and napkins he uses in a conference room to give you the skills you need to work on the project and it makes it realistic. I've read hundreds of books but this is the first tech book that has really made an impact in my career in terms of the way I think about writing, if more books were written like this tech books would be best sellers!!! Paolo Perrotta Thanks for writing Metaprogramming Ruby!

I've never written reviews on Amazon, but I felt I had to for this book. It's very elegantly written, as he takes the same format as the way one learns software craftsmanship in real life: solving real world problems under the guidance of a mentor.

In this scenario, you take the role of a new employee at a company guided by the Ruby expert named Bill, on a one week crash course journey though the object model, method creation, blocks, class internals, and finally putting this all together to write a piece of code that seem oddly familiar to the base files you see in some of the famous gems.

The book then goes on and ties this ruby knowledge to a Rails specific lens, examining the internals of ActiveRecord, taking a quick tour of Merb, and then having a glossary of metprogramming "spells" useful for everyday work.

This is a gem (no pun intended) among Ruby books and, in fact, among programming books in general. What sets this book apart from other programming books is its focus on having the reader deeply understand the ruby programming model whether you are a novice or an expert. This is an achievement few other programming books can claim. While meta-programming in ruby is certainly a pleasure when compared to other oo languages, it is still a rather arcane subject, and for this author to be able to explain it on a deep level to beginners is simply awe inspiring! There is also plenty of material for the advanced rubyist including a chapter devoted to what I like to call "dynamic adaptive programming" but will be known more familiarly as "code that writes code". But even the expert will want to read the whole text for its clear, almost zen-like treatment of meta-programming. If I were to be a complete novice to ruby, instead of reading the basic texts like Programming Ruby 1.9: The Pragmatic Programmers' Guide (Facets of Ruby) and The Ruby Programming Language (although the oreilly book should at some point be read thoroughly at some point), I would simply read this book and the following book in tandem: Design Patterns in Ruby.

Metaprogramming Ruby puts non-obvious and non-trivial content together into a coherent whole.

The technical content of this book is very, very good. The book explains much of the basic structure of ruby (object model, class definitions, blocks, method lookup, etc) in such a way that common idioms that I have previously used without understanding their underlying mechanisms now make complete sense, and my understanding and command of some of the more powerful features of ruby have greatly improved.

Real-world code examples drawn mostly from ruby gems are included, and these are excellent illustrations of ideas presented.

As with many technical books, many of the non-real-world code examples are extremely simple and contrived. For the most part, this is acceptable, but there are instances where the tests/sample output provided for exercises were incomplete -- in the sense that you can come up with a flawed and incomplete piece of code which will still make the test pass.

The thing about this book that drove me up the wall is the insipid story line: You have started a new job, and you have an incredibly chirpy and annoying coworker with whom you must pair program, and who lectures you about the ruby object model, etc. The dialogues are awful; Bill The Asinine Coworker "exclaims" and "shouts" much like characters in bad romance novels supposedly do. The text is littered with irrelevant and distracting details about sipping coffee and grabbing keyboards and ignoring whiteboards in favor of napkins.

This is possibly the best exposition of the ruby object model available, however, so if you are frustrated by the piecemeal information available on the web and you don't have a chirpy co-worker by the name of Bill to mentor you, I would highly recommend reading this book.

Anybody who has wondered about the magical code in Ruby source code and has had only a patchwork understanding of Ruby metaprogramming from various sources will find it all explained here.

The major complaint about the book from these reviews is the narrative style of the exposition. I read the complaints before picking up the book so I was prepared--and found them unwarranted.

The purpose of the story and characters is to provoke thinking and understanding. The method succeeds.

Coming from Java, this book was very important for me in filling in a lot of the gaps in understanding Ruby. "Metaprogramming" may sound like a topic best saved for expert practitioners, but I think this is important stuff for everyone - you'll actually understand how all of that magic code you see in various modules and libraries works under the covers.

I would read this before reading a Rails book.