Customer Reviews

Pro Active Record: Databases with Ruby and Rails (Expert's Voice)

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

 

 

Right at the start of Pro Active Record the authors address a possible problem some may have with it: that there's not enough in Active Record to warrant a full book. They point out that the basics are well covered as sections elsewhere but that this is the first book to really dig into working with legacy schema and other `advanced' uses. That's fair enough, but after reading the book I am still left with the question of why, then, they dedicate the first half to covering ActiveRecord's most basic concepts?

Judging from postings on the rails email list, there's certainly a lot of confusion about ActiveRecord, associations, observers, how to work with legacy table names and primary keys, and so on. But in a book with a title prefix of "Pro" I was expecting to jump straight into the nitty gritty of topics like compound/composite primary keys and performance tuning, probably with some real world examples, and maybe with a serious exploration of AR's internals. As it is, such topics only get a quick treatment in the final chapter (the compound/composite primary keys section is a paragraph referring users to a plugin).

It's almost always instructive reading other developers' code and it would be unfair to claim that I didn't spot a couple of tips that may prove useful, but they were passing things. And sometimes I found myself wondering what happened to the tech review process, particularly in the coverage of the has_one association, where not only is the variable naming confusing, but they seem to be calling the each method on a single ActiveRecord instance.

I'm left wondering what the audience is for this book. The title and blurbs suggest it's pitched at people who want to go deeper into ActiveRecord than they have before, but the content is better suited for someone with some database experience who wants to pick up ActiveRecord to write some scripts. As it is, if you've worked with ActiveRecord before your time will be better spent writing plugins and exploring the internals for yourself, and if you've not you'll get most of the same material from a decent Rails book and some time exploring.

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

Visuals:
Font size and layout are good. Easy on the eyes. Large and frequent sub-headings make it easier to locate information.

Audience:
The book lists it's intended "User level" at "Intermediate-Advanced".

Practicality:
It really depends on what you are expecting. I've been using Rails and ActiveRecord for about 2 years, so I should fit into the target audience. After reading the book I still think it will be a great reference book to have within arm's reach while working with ActiveRecord. To me it will serve as an API to AR. So it will be practical in that sense.

On the other hand, while reading it I never experienced any "aha!" moments where I felt like I learned something new or exciting, which I had hoped for from a "Pro" book.

If you are a beginner (never having used AR) it will definitely save you time (and eye strain) hunting down tutorials on blogs.

Overall:
It's a good Active Record reference & usage tutorial(s). I would have appreciated this book even more when I was first starting to use the Ruby on Rails framework. So if you are a beginner, don't let the "Intermediate - Advanced" user level scare you off. If you are using Rails, even as a beginner, you will probably be using Active Record too. In fact I think this book would probably be better named "Beginning Active Record" instead of "Pro Active Record".

I was kind of surprised when I read the Introduction to the book that it starts off with:

"Is there really enough to talk about in Active Record to fill a whole book?"

"Our answer, then and now, is, "Yes and no""

As an "Intermediate - Advanced" user, that's kind of how I felt at the end of this "Pro" book.

I give the book 4 stars, with the assumption that you go into it with the expectation of "Beginning Active Record".

ProActive Record fills a void in RoR texts. From some of the descriptions I was worried that the book would be too focused on using ActiveRecord without rails. My assumptions were unfounded.

By having basically unrestricted space to focus on one part of the MVC framework, the book is able to go into much deeper discussion about many of the topics on ActiveRecord covered only partially in previous Rails texts.

This book focuses on the practical instead of the abstract to its credit.
One chapter is devoted entirely to real world issues in a Q and A style that most every Rails developer will eventually face. It is more like participating in a lab rather than being preached to in a classroom.

Note while this book does not target total beginners it is extremely useful for someone who is past the newbie stage.

Highly recommended for the RoR professional.

My team was midway into our first big Ruby on Rails project, and we were having some problems with database interaction. We were migrating an older, fairly complicated database from MS SQL Server and C# .Net to RoR and MySQL. This book walked us through exactly how to handle some of those complicated situations, like how to update two tables from the same form, with one table having one row updated and the other table having several rows updated. I would consider the book perfect for anyone migrating a database from an older system.

No fear of the legacy database!

Excellent book overall, but Chapter 7 is what takes the cake for me.
It's generally considered a pain to use ROR with legacy databases, but
K.Marshall et al, show that it is not only doable, but not bad at all.

Excellent examples and explanations, showing code in a step by step approach - starting at the very beginning (what active record is, configuring/installing it, etc...).

At the same time, the style is extremely laid back (at times the authors poke a bit of fun at each other), which is always welcomed when learning something new.

Great book and great choice to include information on getting active record working with legacy databases.

Honestly, you may want to pass on this one! The pragmatic book's coverage on this as well as the online resources should be enough to get you by. There were no aha moments with this one, it is a bit of a dry read, with some repetition. I was hoping to dig deeper into the magic that allows ActiveRecord to learn your table names by introspection with some specific gotchas relating to feature support across the different DBMS. I feel like I have a reasonable resource book to allow me to search for ActiveRecord information in one spot. However it is nowhere near as good as Obie Fernandez's The Rails Way as far as references go. There are sections in there which are too repetitive and which may have been aided by the use of the occasional table (pun not intended!) or two.

There may just not be enough material in here to warrant the expense. However, the idea was good and there may still be hope for a second edition with a bit less repetition and more in-depth discussions.

I was ecstatic when I heard a book dedicated strictly to Active Record was being written and signed up for a copy right away. As a Java developer with just a little bit of Hibernate experience, Active Record has been my biggest challenge learning ROR (in addition to some of the Ruby language idioms). I've read a lot of the other Rails books (e.g. Prag Programmer series) which also cover Active Record, but not in as much detail as this book. In particular, I found the numerous code examples very useful and easy to understand. The authors provide a lot of "here's the SQL generated by Active Record" which help me better understand the "man behind the curtain".

As some of the other reviews have already stated, the introductory and overview sections of this book are excellent. After that, there is a chapter dedicated to explaining the core features of "Active Record". That helps lay the foundation for the rest of the book which covers more advanced topics. Depending on whether you're working with a new schema or legacy schema, there are a lot of tips to help you successfully use Active Record in your real world application.

Hibernate is Java's ORM equivalent to Rails Active Record. The book "Java Persistence with Hibernate" is a whopping 841 pages. "Pro Active Record" is 280 pages, so it's only fitting that the ROR persistence framework can be explained in 1/3 the number of pages. Don't be discouraged by the size of this book as it packs a lot punch. I currently own almost all the good Ruby / ROR books, but this book is one that I always keep by my side.

I have to wonder if people that buy the "for idiots" series of books expect that they were really written "for idiots"?

Just because this book is called "pro", does not mean that it's some super high-level diatribe about active record. If you're such a pro, just read the source code for active record, all the docs you need are in there. If you want to actually see some examples and read a fair discussion, this book will suite you well. The worst thing about this volume, and most others from APRESS is that if you want an eBook version you have to pay additional fees and then get a "locked" pdf of the book. Wake up, APRESS - get with the Kindle program.

The first few chapters are very good. This book should actually be called as Introduction to Active Record. Not all advanced features are covered in this book. Jamis Buck has explained the advanced features in his blog very well. This book has done a good job introducing the beginner level concepts.