Customer Reviews

Practical Ruby Gems

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

 

 

Practical Ruby Gems does exactly what it says on the tin. The first few chapters cover what gems are, how to install them and manage versions. The final chapters cover how to create and distribute your own gems.

Sandwiched between these fundamentals are a slew of concrete examples with code, covering topics like html parsing (hpricot) and RSS parsing (feedtools), zip and pdf manipulation, as well as topics more familiar to Rails people, such as the use of mongrel, rake, and ActiveRecord.

My first impression was that info on specific gems could easily be found by checking their documentation online.

However, after reading more, I realised I had missed the point. In theory, you could get this stuff online, but in practice, the often poor online documentation can't replace clear explanations and concrete code examples. This book fills you in on the fundamentals, then gives an interesting tour of some of the major gems available, with ready to use code. By bringing this all together, it will almost definitely spark some ideas on how to use gems to improve your Ruby code or your Rails apps.

I'm learning Ruby and building Rails applications. This book offers a valuable overview of some of the Gems available for expanding the power of Ruby, including detailed descriptions of a selection of popular Gems. Things like online image manipulation and PDF creation are possible to easily implement with some of the Ruby Gems described in this book.

David Berube, Practical Ruby Gems (Apress, 2007)

If you've been following my reviews and you've seen the Ruby and Rails books go by for the past year, you probably know exactly what I'm going to say about this one before I even say it. So I'll keep this short and sweet: it's dated, but you'll learn some interesting stuff from it. Which is true of pretty much every Ruby book I've seen come across my path that was printed more than a year ago. Such is the curse of only being able to afford used copies of computer books, I guess. (Hey, Apress: if a few Rails 3 books were to come Amazon Vine's way, no one would complain.) ***

This book contains three parts:

Part 1 deals with what gems are, how to install them and do version control.
Part 2, the biggest part of the book, contains chapters that deal with different Gems. All of them contain a description and one or two practical examples on how to use the Gems to get something done. All code is explained after that. The book focuses mostly on Gems that can be used in a web development or sysadmin context.
Part 3 is about creating and distributing Gems yourself.

I think the book is a nice read for starters who finished reading their first Ruby book and now want to create something useful. But I think it can be informative for more experienced Rubyists as well. It's pretty well written but I found that a few code listings contain flaws. This is mostly because the Gems used have been renamed, made obsolete by different gems or had other adjustments. So it's mostly due to the books age (April 2007) and some specifics of my operating system (Ubuntu). The publisher has not posted any errata and the downloadable code is flawed as well (at least on my system). This was a bit disappointing, but my opinion is that it's still a valuable book that will save you time in the long run. I bought the book second hand for 10 euro's so I'm pretty positive about purchasing it. But I think I would not spend the full price on the new book, but rather wait a possibly second edition or a good discount offer.

http://geekatlarge.blogspot.com/2009/05/books-anyone.html

Some books are more tutorial in nature, some more reference. This one is *really* reference, so much so that if you don't need to use the covered gems, there's no reason to buy the book.
I agree with one reviewer about much online documentation being lacking (to put it mildly), so this book is definitely helpful in that respect. Still, I found the explanations to be on the terse side. (Which some people might prefer.)

Ruby has risen meteorically in prominence in the past few years, and the number of Ruby books has gone from a couple to a couple dozen. I'm pleased to say that this is one of the books that will remain on my bookshelf. Practical Ruby Gems makes few assumptions about the reader's level of knowledge and delivers a brief install-configure-manage tutorial to get novice readers up to speed. The main bulk of the book is 29 short chapters which each highlight a single gem, explain what it's used for, gives a simple script demonstrating how to implement it and has some added commentary on its applicability and explaining the implementation. The final two chapters explain how you can create and distribute your own gems publicly or privately. Overall, the book is clear and concise and filled with useful material.

Disclaimer: I have known David for several years, and we worked together to deliver some LAMP training and run the local LUG. I'm impressed with his level of knowledge and his ability to communicate it, and this book is an excellent demonstratin of that.

For those who aren't aware, ruby gems refers a way of packaging up code so it can be easily distributed for other developers to use, and a tool to help with the distributing and/or installing that code.

On first glancing at this book, I wondered how you could fill a full-length book on the topic of gems. While getting the tools installed on some systems requires care, and there's space for a couple of chapters on packaging your own libraries as gems, both topics have been covered alongside other topics in numerous volumes. What I'd missed was that contents not only covers both of those topics, but also looks at 26 different gems and explains how you might use them in your projects.

The coverage of setting up and using ruby gems at the start of the book, and on packaging and distributing your own gems at the end of the book are brief but cover the basics well enough. It might have been helpful had the latter included a little information on how to include other libraries that need to be compiled and managing the cross-platform issues that raises. Chances are anyone planning to do that is well capable of reverse-engineering a gem spec file to work out what's needed, but it would have added some weight and helped these chapters stand out from their equivalents in other volumes.

The gems profiled cover a wide range of uses: databases, certain web services, parsing HTML, web frameworks, recurring events, PDF generation, and more. Most of them are pretty well known libraries, but few of us will have had a chance to try them all out and newcomers to the ruby community looking for some support in their projects may well find some useful tips within.

For each gem there is an introduction, some basic code samples, a lengthier code sample (with commentary) and conclusion. That repetition means this isn't a book many will want to wade through in one go. I found that after a while I needed a break, and if reading the book it may be best to pick out a gem that particularly interests you, read the relevant section and then write some code of your own before moving on to another.

A number of times I wondered if it would be preferable to drop some of the best known gems (there are plenty of ActiveRecord examples floating around) in favour of a little more depth. In particular it would have been interesting to see a dissection of how a few of the gems work, as a sign that anyone can contribute, to see what can be learned from techniques used, and to better understand how the gems in question can be used. Such explorations might serve to break up the text a bit, as well as providing useful insights into ruby development and perhaps broadening the appeal of the book a little.

Overall, Practical Ruby Gems was a helpful read and there are a few new gems I'm going to be exploring as a result of my reading, but you may well want to take a close look before investing in a copy. You may broaden your ruby knowledge in the reading, but you're unlikely to deepen it significantly.

Disclaimer: I was sent a copy of this book for review by the publisher.

For a book that focuses exclusively on ruby gems you would think it would cover how to wrap a C extension up into a gem. No, in fact, the material on creating your own gems is exceptionally paltry. This book is evidently only for extreme new comers to ruby and the gems world; there is no coverage of advanced topics.