Customer Reviews

Ruby for Rails: Ruby Techniques for Rails Developers

5 star:		(34)
4 star:		(8)
3 star:		(4)
2 star:		(5)
1 star:		(3)

 

 

I am extremely pleased with this book, and I think it's because I read it at the right point in my studies of Ruby and Rails. I have no Ruby background (Java, mostly) and wanted to pick up Ruby on Rails because of how great it all sounded - sidestepping so many of the problems of JSP/ASP/PHP/etc.

So, the first book I picked up was the PickAxe book, and read it pretty much from start to finish. It turns into a reference about 2/3 in, but the first part of the book is worth a straight-out read. That book gives you everything you need to get up and running with Rails, and has some brief coverage of the Ruby language, semantics, etc - enough to get you by.

Between that book and some Ruby language-related websites, I could build a decently complex web app. I discovered the various helpers from ActionView and got better at building good models with ActiveRecord, and understood the overall flow of the application. I was hooked on Ruby on Rails.

But, if you're like me, you eventually find some of the mystery frustrating. How does inheritence really work? Why do I see modules in some places and classes in others? How do you you make them aware of one another? When I generate a Rails app, what code is it building and where does it go? How come I can use the logger object in my controller, but my helpers can't see it? How does active record know about my database fields?

The mysteries pile up and you eventually need more, but I found the general purpose Ruby book "Programming Ruby" wasn't sticking with me. It covered a ton of topics I didn't care about, and the ones I did care about I didn't realize I was supposed to, because it wasn't obvious how the Ruby in the book related to Rails.

Then I picked up this book - and it was *exactly* what I was looking for. It has answered every question I've listed above, and I'm only halfway through it. I'm finding that I'm actually *understanding* what's going on with Rails under the hood.

Admittedly, if I'd started into this book as a primer for Rails, or a Ruby reference, I probably would have been disappointed. But, that's not what this book is all about. This book has a very important place in the process of one's learning about Ruby and Rails. At this point in my learning, I've found it to be perfect.

I was really disappointed with this book. It got very good reviews so I bought it without ever looking inside. It says it's written for programmers from many different backgrounds, but it's really for fairly new programmers. The author repeats himself a lot and is incapable of stating things in a concise manner.

I would prefer a book that gets right to the point and highlights what's important or not intuitive. The intro section on MVC is a good example of his repetition. You find yourself thinking you're reading the same sentence several times.

You'll still learn a good amount about Ruby and Rails from this book, but if you've been programming for a while you'll be aggravated by the pace this books introduces the material.

So in short, if you are relatively new to programming, this could be a good book for you. If you are looking for a quick start this may also meet your goal, but it's done in about twice (maybe three times) as many pages as necessary.

The book's preface indicated that the author is well versed in Ruby, and that he got into Rails when it was brand new. It sounded like he was in a position to teach the subject matter well, and I really liked his angle: Rails was written in Ruby, and Rails extends Ruby... you really cannot fully utilize Rails without learning Ruby, and this book teaches you all about Ruby, with an eye on Rails. Perfect!

There are four parts to the book. The first part is an introduction which explained how Ruby works, how Rails works, and why it's important for Rails developers to have a good handle on the Ruby programming language. This was more detail than I had gotten in my online reading, and not so much detail that my head blew up immediately. A real plus. Also in the first section, we walked through the beginning of the development process for a simple "music store" web application. This defined a context for the pieces of the Ruby puzzle that were about to be dumped on the table.

The second part of the book really delved into the guts of Ruby programming. It defined objects, variables, classes, instances, constants, modules, methods, inheritance, scope, and control flow techniques. It had been 8 years since I'd done work in Java, and that was my only experience with object oriented programming. Ruby is kind of the same, but not really.

The third part of the book is all about the classes and modules that are built in to Ruby. This is very important stuff, necessary in order to get a feel for what you can do (manipulations and comparisons) with different data types. And there is a lot you can do. This part also describes how arrays, hashes, and regular expressions work in Ruby.

The fourth and final part of this book re-focuses on the music store application from earlier in the book. Once you've gotten a tour of Ruby, you see Rails development in a different light. Controller and model files look different when you have a feel for what you're actually looking at. With your new perspective, the author walks you through several improvements, bringing the online music store closer to reality.

As a kind of a bonus, the final chapter of the book gives some techniques for learning more about Rails (and really, Ruby, too.) This is very good stuff! How do you search through the Rails code to find the section that pertains to your question? How can you more effectively search online documentation? Answers to these kinds of questions can really help a person grow, because once you become an intelligent troubleshooter, the only thing holding you back is your own level of motivation.

There are many good books on Ruby, and on Rails, so many deservedly 5-star rated ones, that you'd think there'd be no room for yet another one.
Until you read this one.
The author covers everything about Ruby, and he has a special feel for those important, but advanced and sometimes difficult points, which you've always wanted to understand, but didn't quite grasp.
His sense of humour is especially nice, because besides keeping up the reader's attention, David's elegant formulations are always to-the-point pedagogic (besides being funny).
The author's claim is that you should know Ruby well in order to fully exploit Rails.
Yes, after studying this book, it becomes obvious that he's right. Invest some time (hours, days, weeks, depending on your start level) on studying this book and its examples, and you'll become very proficient in Ruby (even the advanced topics), and at the same time you'll have gained a much deeper working knowledge of Rails.
Highest mark on "value for money" ratio. It's probably the best computer book I've ever studied.

I found this book to be absolutely essential to understanding what I was doing while programming with Rails. After reading this book a lot of things became clear in the Dave Thomas book (Agile Web Development with Rails). If you're thinking about hiking up the Rails learning curve, you'll be most of the way there once you finish this book. I had no previous experience with Ruby, but I have programmed in C++, Java, PHP, LISP, Javascript, and several other less well-known lanugages. Probably for that reason, I thought it was kind of a slow read. However, I think it would be a great book for people with no prior programming experience. It would make a great textbook along with Thomas's book. Personally, I much prefer a clear, verbose style than a terse style that assumes a lot of prior knowledge. I read this book after Dave Thomas's book, but I recommend reading this FIRST (or closely along side of it).

If you are one of the many new developers coming to Ruby through Rails, this book is certainly required reading.

Within these pages you will find a solidly paced and effective tutorial of the Ruby programming language. The book speaks to programmers with only a little experience and yet experienced Rubyists will likely learn a few things by the end. I know I did.

The book does a nice job of keeping the material Rails centric. Examples often show a Rails slant, though the concepts are primarily vanilla Ruby. This allows you to learn powerful new techniques that will likely help you in many new areas while staying focused on the current goal.

This book also has the best description of Ruby's "singleton classes" yet put in print. It's probably of value to all Rubyists for that alone.

I highly recommend this title.

Ruby for Rails really covers how ruby and rails fit together and the idioms that derive from each.

The book covers a lot of ground, some of which is only relevant to those new to OO programming, but these section can be easily skimmed. For the experienced programmer it also covers a number of Ruby features that are not basic such as singleton methods, method rebinding plus some meta tasks e.g., using 'method_missing', trapping inheritance etc.

I've read two other Ruby/Rails books and they were very helpful in coding my first Ruby app last year, but they left me with many questions about how things really work.

This book answered most of those questions and opened up a couple of new doors that I didn't even realize were closed.

My introduction to rails started with the Agile Development book, which is great, but I kept asking myself - how much of this is Ruby? and how much is specific to Rails? . Ruby for Rails provided me the answers.
I really enjoyed reading this book. Even when it covered material that I already knew, it still offered a few new tips for me.

I discovered a couple confusing items in the book, and I used the author's forum to ask questions. The author answered my questions, clearing things up for me. I was very impressed.

You might imagine that David Black's Ruby for Rails is a quick run through Ruby as an attempt to cash in on Rails hype. While I'm sure the interest in Rails helped in getting this book published, this is not a quick cash in attempt. This is one of the best Ruby books available. Dare I say this book tops the esteemed PickAxe (ie Programming Ruby: Second Edition) by the Pragmatics? Maybe...

David Black is a director of Ruby Central, ruby-talk regular, consultant and presenter. He knows and loves Ruby, and it shows in this book. His style is informal and easy to read. My only (minor) complaint is that its a bit verbose at spots, with some points being made many times over in different chapters.

The book is divided into four parts. Part one is the standard "quick-start" piece, with three chapters doing a quick overview of Ruby and Rails. He also introduces the Rails app that is used for examples throughout the book, R4RMusic - a classical sheet-music store. One minor nitpick is that Black uses straight sql instead of migrations for his database setup.

The second part cover's the fundamentals of Ruby, so if you've read the PickAxe or one of the online intros much of this will be familiar. He covers modules and classes, control flow, exceptions, and variables and methods. Experience programmers from other languages can probably skim through this pretty quickly, but those newer to programming will find this material invaluable. There is also a chapter devoted to the all important role of self and how scope works in Ruby. This helped clear up some confusion I had about just where methods go when they are declared at the top level, and where and where "functions" like puts and friends come from in irb.

Part three covers the core libraries, regular expressions, and metaprogramming. String, Numeric, Time, Date, Array and Hash are discussed in depth, with plenty of examples, which is always helpful if spent any time trying to figure things out with the online api. The regex chapter is one I continue to return to, as I can never remember the syntax needed to get typical things done.

Chapter 13 is the metaprogramming chapter, titled "Ruby Dynamics", and my favorite out of the whole book. Black first covers the oft-misunderstood singleton class, how to access it and modify it, and where it lies in the message chain. Class methods are explained as a special case of singleton methods on objects of class Class, using some helpful diagrams to show how inheritance works with all of this. The eval family of methods is then covered, starting first with the redheaded stepchild "eval", followed by little brother instance_eval, finally covering everyone's favorite girl next door: module_eval, aka class_eval. If you've done any digging in the Rails source or done metaprogramming yourself, you've probably seen or used it. Its one of the most commonly used methods for adding or changing methods at runtime in Ruby.

Procs and lambdas are explained well along with their relationship with blocks. This section includes a nice analogy for closures:

"Creating a closure is like packing a suitcase. Wherever you open the suitcase, it contains what you put in it when you packed it. When you open a closure (by calling it), it contains what you put into it when it was created."

Callbacks such as method_missing, included, and inherited are covered, with an illustration from ActiveRecord::Base.inherited showing how new AR subclasses tracked using the callback. There is an all too brief section covering open classes and how to change existing methods, and the dangers that come with that power. The one problem I had with the entire dynamics chapter is that I wish there was more of it! The content is spot-on, but there could be a whole separate chapter discussing the pros and cons of the various methods available and idiomatic metaprogramming versus inadvisable techniques.

Part four is the final and most Rails-heavy section. He walks through building up a rich domain model through adding on to the ActiveRecord models and also how to separate functionality in the view with helpers and partials. Much of this content was not new to me, having already covered much of it with the Agile book, but I can see the value for newer Rails programmers. My second fave chapter, 17, explains techniques for exploring the Rails source. The ActiveRecord class method "belongs_to" is used for the primary example, but again I was frustrated as it seemed Black only scratched the surface of what is going underneath. A whole chapter could be done just showing how a belongs_to association is generated and handled, and could use the Rails source to illustrate some of the common metaprogramming techniques that you see in Rails and elsewhere. As it is the coverage of belongs_to goes far enough to show how the methods goes from an instance method in ActiveRecord::Associations::ClassMethods to a class method available to ActiveRecord::Base. Whiles its enlightening, I wanted more from this chapter.

Overall, Ruby for Rails is an excellent book. My main complaint has to do with wanting more advanced, in depth material, and given the amount of ground the book does cover (just under 500 pages, btw) I understand the book had to be completed in a reasonable amount of time. The material that is covered is explained clearly and patiently, with a lot of coverage given to the core classes and object model that make up Ruby. For Java/.Net refugees or those Ruby beginners looking to enhance their skill with Ruby, I would strongly recommend this book. And yes, I'd even recommend it over the PickAxe.

This book is a must have for Ruby on Rails developers.

While you could develop Rails applications without understanding Ruby, to do would completely miss out on the reason Rails was created in Ruby. Ruby is a powerful and enjoyable language.

For those of you that do not know of David Black, here is a part of the bio from his book: "A Ruby community leader, David Black is the director of Ruby Central, the parent organization of the annual International Ruby Conference (RubyConf) and the International Rails Conference. David is a Ruby core contributor and the creator and maintainer of RCRchive."

The reasons you must know Rails to become an effective and efficient Rails programming machine:

1. To understand the Rails source code

2. To make your Rails apps do something beyond pushing data in and out of a database.

3. To take advantage of "Ruby everywhere"

4. To use Ruby for non-Rails tasks (automation).

5. To enjoy developing Rails apps!

There are books on Ruby and there are Books on Rails. David Black is one of the few authors out there that can lead you over the bridge that connects Ruby and Rails. David has a deep and broad understanding of Ruby that he puts to great use in this book. He uses this knowledge to lead you through not only how Ruby works, but also how Rails uses the power of the Ruby language to deliver an efficient and enjoyable framework. Here are some topics he covers:

Part 1: The Ruby Rails Landscape The first two chapters are introductory overviews to getting your "Hello World" Ruby and Rails programs running. For anyone that has written a Rails program, there is not much new in the first part of the book.

Part 2: Ruby Building Blocks The next section has a very interesting discussion about Rails as a domain specific language and how Rails feels more like configuration vs. programming. For example, David shows how the Rails declaration has_many :editions is a method call that could be written in several different ways. The Rails idiom of has_many :editions is syntax that makes Rails feel more like configuration and less like programming. This same method call could also be written in your controllers as send("has_many", "editions".intern) or has_many(:editions).

Similarly, David's discussion of Ruby "syntatic sugar" is enlightening. Syntatic sugar of Ruby allows the programmer great power in the setter methods. It does it more easily and cleanly than other languages (in my opinion). For example, in the setter method def price=(amount) @price = amount end

the method name is "def price=". To call the method would look like this: ticket.price=(65.00). By allowing you to put a space before the equal sign in the method name and allowing for parens to be optional, Ruby allows for a much more pleasant: ticket.price = 65.00

What makes Rails great is the combination of Ruby's flexibility as a language and ability to support "syntactic sugar" and the Rails community's positive support for coding conventions that have created standards. When reading and writing Ruby for Rails code, it is important to understand the differences between what is a Rails community standard and what is a Ruby language expectation. This understanding will give you the powers itemized above.

This combination of technical and philosophical conversation continues throughout the section brining to light important information on managing classes, constants, modules and mixins, control flow statements, and error handling. The books description of how Ruby yielding works is a valuable read and is a good example of how this book helps you understand what is going on in a Ruby program and how to become a good Ruby and Rails developer.

Part 3: Built-In Classes and Modules This section is pure Ruby and describes things such as scalar objects, containers, collections and regular expressions. In my current project, this book's 24 page discussion on Ruby regular expressions was worth the price of the book itself, allowing me to replace custom methods I had written with a few lines of regex. (email me at scott [at] synapsoftware [dot] com if you want the technical details on this statement)

Part 4: Rails Through Ruby, Ruby Through Rails The book concludes with a step by step walkthrough of the sample application. It discusses not only the how but also the why of Ruby on Rails design decisions. That is what I liked best about this book. The final chapter invites you to learn more by exploring the Rails source code. It steps through three techniques for discovering how Rails leverages Ruby.

My only complaint: a chapter on the testing framework should be added. Unit tests are such a big part of the Rails development experience that they should have been covered.

Read this book and become the next Rails star on your team.