Customer Reviews

Agile Web Development With Rails

5 star:		(45)
4 star:		(12)
3 star:		(1)
2 star:		(1)
1 star:		(2)

 

 

It does not reflect the current state of Rails at this time. A new version is supposed to come out in October 2008 that covers 2.0. If you get this version you will need to switch to an older version of Rails, otherwise you'll only get about 68 pages in before the examples stop working.

As a web developer, I own literally hundreds of technical books - most of are either thick tomes full of encyclopedic information you'll never use in real life. This book is perfect for learning rails. You jump right in and develop an application - getting a taste for what you'd be doing in real life right away. Datailed explanations are left for later, when you better understand how the platform actually works.

The example application you'll develop, if you follow the book as you should, is a real-world shopping cart type app. Along the way you'll pick up some agile development.

I would not recommend this book to absolute beginners to web development - you should understand some basic web development. This book takes you through everything from installing rails and MySQL to deployment.

I am an oldster (you know, 40+) and have learned many a language. Kernigan and Ritchie wrote their "K & R" C-language book in some written language a little higher level than English. After 40 or 50 reads through, I got it. I read C++ books, SmallTalk, Delphi, Visual Basic, and many Java books, HTML, JavaScript, CSS, Awk, Emacs, REXX (!!), and just about everything O'Reily has ever published.

Now, I come to Ruby, and Ruby on Rails. Thank goodness for this book. What a relief to read a book that is 1) comprehensive, 2) practical, 3) accurate, 4) funny at times, and 5) above all, has a good index! Perhaps programming languages are (finally) getting easier to write about, but Dave Thomas is an outstanding technical writer: he knows his audience and writes for us. Look, I know a million programming languages, but I am not the kind of person who zips through a book and suddenly gets it. Most books are written by people who are experts in the nuances, but have forgotten the many steps that lead up to those nuances.

AWDWR is better. It starts with a non-trivial and complete tutorial -- the first half of the book is an application that manages to hit most of the critical aspects of actually doing the job. It is a reasonably broad application covering many points of real webapps. (I read through thinking, yeah, we managed to deal with that in our Java webapp in a month, and here it is, built in to Rails, and better ... more than once). Maybe it is Rails, which seems to be a significant step in maturity over current generations (my last was WebWork/Struts 2, which seems to be the best you can do with Java these days, but really only one part of the larger problem).

But I have to give great respect to Dave Thomas and the other great writers who all made this second edition book a great, great book. I could follow along when reading, I actually did the whole tutorial and found myself learning almost all the way through typing the examples in by hand (mostly by learning how to debug my typos and understanding how the language and framework responded). Now that we're writing our real software, we still look back at the tutorial to get a clear view of how all the parts fit together.

The second part of the book is a solid documentation of the components and APIs available. It is not complete, but nor should it be -- if you want the API, link to the Rails site API. It does cover the important points, however, and ties them back to the tutorial where appropriate. Various important aspects are covered in enough detail to get the idea across, but not so much as to be just a lexicon.

I can't recommend this book highly enough. If this is your first programming book, it will be a struggle, but less than most, and if you're a professional software engineer with one or two languages under your belt (and reasonable proficiency at the command line), you will find this a great reference for learning, and for doing.

You need this book if you're going to be developing a Rails app, but there are some issues.

#1 -- Learn Ruby first. Although the book's jacket makes it seem appropriate for absolute RoR beginners, you need to know basic Ruby before you're ready to start this book. The author says as much in the first chapter. Ruby newbies may want to consider this author's Ruby book (I haven't read it) or the excellent "Beginning Ruby: From Novice to Professional" by Peter Cooper which is enjoyable and very well-written (which I have read).

-- Many (most?) Rails books feel like they were rushed to press. Perhaps I'm just a little too Type A, but the text sometimes reads as if it was dictated rather than written. Much is assumed or left unexplored. A bit more structure within each step of the app-building process would be very helpful in future editions. A quick outline of the app's classes and cethods, describing what each one does, would be helpful as well.

-- A few times the author resolves problems on pages after the code that caused them appears in the text. If you run into a show-stopper, read ahead to see if he resolves it before you go mad trying to debug your own code. A database session problem was especially annoying.

-- Some of the downloadable code examples from the publisher's web site don't seem to match the corresponding code in the book. It's unclear whether the publisher's code has been corrected or simply reformatted. Regardless, download their code and refer to it (or copy and paste it into your own) as you follow along.

So, take a deep breath and dig in!

I have purposely refrained from posting a review of this book though I had purchased the First Edition of this book back in October 2006 when I was getting started with RoR. I have gone through it and purchased the Second Edition and am going through it now.

The first time around, my knowledge and experience with RoR was quite limited especially the Ruby knowledge. It became clear to me that I needed to learn more Ruby before I could begin to grasp what the first edition of this book was all about. I went back and bought David Black's Ruby for Rails Developers book and went through it entirely working through the whole code base. I had to repeat certain chapters a few times to really understand what was going on. Since then, I have gone through Patrick Lenz's "Build Your Own Ruby on Rails.." book and have now come back to the Second Edition of the Book and working through the Depot application again. This time around though, my appreciation for the material in this book has gone up since I am better able to grasp it. I may have to repeat certain Chapters/Sections a few times to round out my knowledge but that is OK.

My advise to people getting started with Ruby and Ruby on Rails is that do not make this your first RoR book (I would say the same thing about the PickAxe or Programming Ruby book). Instead, buy some of the starters books, e.g., the ones that I mention above, and go through them first. If you do that, you will be in a much better position to learn effectively from this book. This book tries to get you running too soon too fast. You have to walk before you run.

Other than that, the materical in the book is obviously written by people who have an expert level understanding of the product and they know how to communicate it well.

When approaching a relatively new platform coming from a substantially more established one, the first question that rises is, "what about literature?" This book single-handedly answered any qualms or doubts our team had about Rails documentation/literature. Dave's exposition is bar none as is his knowledge in the subject. His writing is straight forward, no-nonsense, and w/o using arcane/ethereal words to make himself look smarter. This book embodies both the Rails philosophy and the Ruby philosophy; it's simple, to the point and gets the job done. It's about the only book that comes to mind that really does a good job at presenting the framework/language to the beginner, re-inforcing knowledge to the intermediate Rails programmer and teaching new things to advance Ruby programmers. All without confusing or neglecting either target audience. Our team owns several copies of about 7-8 different Rails book, and I can say with confidence that we refer to Mr. Thomas' book about 95% of the time, perhaps more. In short, great book, great author, well organized and a must in your or your team's bookshelf.

This book, for me, was fantastic! Real world examples for the win! I am still not finished with this book, only half-way through it but, I have to say I have never been as excited about a book than I am about this one.

The very beginning chapters get a functional website application up and running called Depot (an on line book store) and they do this in such a way that you don't have to know the Ruby language (no, it's not scaffolding). As long as you can understand how gears work and fit together and that one turns clockwise and another turns counter clockwise, I don't think you'll have a problem.

With that being said, without knowing Ruby, you may be able to get by on making your own application from scratch but, it will be very rough. The purpose of this book is to teach you about Rails, not Ruby.

My recommendation is, read this book first, before a Ruby book. That way, seeing the Ruby code will be much easier to take in after you see how it works in Rails and to syntax used. Do NOT skimp on learning Ruby after you read this book! You will be sorry! There are TONS more to learn just by learning the language itself. There is more than one way to skin a cat and by learning the rest of the language, you will be more empowered to figure out problems on your own.

The only problem I had with this book was that, in the middle of chapter 5, it skipped back to chapter 3 and finished out chapter 5, chapter 6 and half of chapter 7 was missing. This is the printer's fault, not Amazon's or Pragmatic Programmer's fault. If you happen to get a messed up book, don't contact Amazon, it takes forever. Instead, I contacted Pragmatic Programmer via email and let them know of the situation and to my surprise, they sent me a brand new book still in plastic, priority mail which took about 2 days to get to me! I was just expecting maybe the missing chapters in PDF format but, this shows a lot of character on the part of the company (Pragmatic Programmers). My email was responded to in less than 45 seconds after I hit the "send" button. I would like to offer much praise to the company for this!

If you are a PHP developer, there is another framework that has been modeled after Ruby on Rails called CakePHP. It is fairly new and under heavy development but, the basic principals are the same. The only reason I am plugging them here is, without having learned this framework, I don't think I would have thought about looking at Ruby on Rails. For a super quick breakdown of how MVC pattern works. Be aware that Ruby on Rails is much easier. I think this is due to the nature of PHP and not the framework itself. The devs try their hardest to make it easy for you.

I guess I don't have anything else to say about this except, if you do buy this book, you will not be disappointed.

I'm almost new to Ruby, have the Pragmatic Programmer Ruby book but it's half read.

Anyway I wanted (in fact needed) to go on with rails and learn ruby on the fly.

This book is what you need if you are in the same situation, it has a very useful Ruby appendix and the book is very well structured, it's a "hands on" book but you won't miss the concepts.

Like many Java developers, I was interested in learning what all the fuss about Rails was about. This is a great book that walks you through building a simple Rails application, learning not only Rails but also some useful agile development techniques that are sometimes forgotten in the Java world (specifically, "Don't Repeat Yourself").

This book was eye opening in that it got me thinking about the benefits of not treating Java as a one-size-fits-all solution to all problems, but rather leveraging the right tools for the right job to create value as quickly as possible and with the highest possible quality. The value of Rails that this book has demonstrated has got me thinking about other tools that could be used when a Java solution would be overkill, such as Python for simple cross platform GUI applications.

As you can tell from the other reviews, this is a great place to start learning Ruby on Rails, especially if you are new to programming and do not have an extensive background with more than one language/technology.

Developers with a strong background in one (or more) web based technologies/languages/frameworks will find this a little too light at first (the example application - depot), but will learn more in the tutorial reference portion (second half of book) where the authors focus on what exactly is Rails.

Not a lot about Ruby the language, but if you have a strong background in Perl or Python it is not too far of a stretch. I have not found a great Ruby book just yet, so I cannot offer advice on that one.

If you have a strong web programming background then you will most likely want to get something like this...

The Rails Way (Addison-Wesley Professional Ruby Series)

The big pain now will be that Rails 2.0 has been released and the tutorial will frustrate newbies (nothing wrong with that, we are all new at some point) as several commands no longer work as they did in Rails 1.0+ and without a good knowledge of the environment you will be stumped. Fortunately, there is a copy of the depot application in an online tutorial format (http://fairleads.blogspot.com/2007/12/rails-20-and-scaffolding-step-by-step.html) that will aid some of those that get stumped by the tutorial until the 3rd edition comes out and covers Rails 2.0+.

Once you get up and running on Rails and want to build some cool apps, then check out another book by the Pragmatic Programmers publisher Rails Recipes (Pragmatic Programmers)