Agile Web Development with Rails, 2nd Edition

• #3 in Best Ruby Books

105 Reviews

Sort by: Most Helpful ▲ Date Rating

Ruby on Rails is a pretty young technology. Its first release was midway 2004, and it has been gathering momentum since late 2004. It has yet to see its official 1.0 release. So it is a pleasant surprise that there already is a book available (electronically since June 2005), and that it such a good book!

Why read this book? Since Dave Thomas' credentials as a technical writer are well established (pick up The Pragmatic Programmer if you haven't got it already), this question boils down to: why learn more about Ruby on Rails?

For me, the answer was that I have long been looking for a simpler way to build web-applications. I'm a J2EE developer, and it seemed that every project I joined had a different set of frameworks. All of those frameworks could be configured to work together, and there are even frameworks whose only purpose is to make other frameworks work together. There are tools that generate stubs to wrap frameworks, and frameworks that wrap other frameworks, so that the developer needs not know what the underlying framework is.

Madness.

Rails behaves as if it were one framework. Configuration is simple (no xml) if you need it at all, since the defaults are pretty smart. Writing tests for your model and your controllers is actually easy. The API documentation is very good. Instead of mucking around with frameworks, you find yourself thinking: What do you want to do today?

Drawbacks: Is Ruby on Rails slow? Performance is acceptable, I think, especially considering that web applications are database-bound. Rails also scales well - and anyway, processors are cheap, brains are not.

Is Rails proven technology? Clearly it's not, it's the new kid on the block. More seriously, Rails is still in flux - the core api is still changing, and it could still take some time to settle down. So now is not the time to start huge Rails projects, now is the time to learn rails and build prototypes and small projects.

And with that, this book will be a tremendous help.

This book was in development through July 2005 and provides a timely introduction to the excellent web framework Ruby on Rails. Rails is a full stack, open-source framework in Ruby (see rubyonrails.com). I can think of no better way of learning Rails than buying this book (and Programming Ruby, "Pickaxe 2", if you are a Ruby newbie) and working through the hands-on bookstore building exercise in a weekend. "Agile" development takes center stage, as you might imagine from the title. Because of the dynamic nature of Ruby and the way Rails extends the core language, Ruby on Rails lets you easily modify, run, and test web apps.

The first part of the book (Chapters 4 to 12) shows how to develop a bookstore app in an iterative fashion. A mock client asks for improvements and the authors show how you build a web app that meets the client's needs. A number of best practices have been distilled from other languages/platforms, and you'll see how they come together coherently in Rails. The Model-View-Controller (MVC) pattern for separating data, presentation, and business logic. Integrated testing. Ways to not repeat yourself across code and configuration files. Active Record pattern for handling data sources. In addition to what's taken from other platforms, the Rails developers extensively use the metaprogramming features of Ruby to wrap these best practice ideas in a nice domain specific language, and this book gives you a good overview of the Rails web app language. "Convention over configuration" is another key to Rails development, and a number of figures show the Rails convention in directory layout, naming, and URL mapping.

Although the book is very accessible to Ruby newbies (in part due to an appendix that provides a quick intro to the language), it assumes some knowledge of core Web technologies. You should be acquainted with HTML and databases (like MySQL). The sweet spot for this book might be PHP, Java, and .NET web programmers. The third part of the book drills down into Rails. You'll learn all about the Active Record object-relational mapping layer, and how easily you can specify relationships, validations, and structures like lists and trees. Other chapters focus on the controller and view portions of the MVC approach. The integrated "AJAX" (asynchronous javascript) support gets a chapter, as do e-mail (Action Mailer) and web service support. The book concludes with a couple of chapters on security and the best ways to deploy and scale your web app.

This book was written in an agile fashion; I can't remember another computer book that was in print a single month after editing was finished. Despite the speed of publishing, the book can't hope to cover all the new developments given the momentum of Rails. What won't be in the book but might be useful to Rails programmers? SwitchTower is a new utility to automate application deployment (among other things), and ActionStep will be a Rails-friendly framework for writing rich GUIs that target the client-side Flash player. But if you want to learn what Tim O'Reilly said might be the "perl of Web 2.0", you should start with "Agile Web Development with Rails" and supplement it liberally with readings off the web.

Highly recommended book. Although this is the first of more than a half-dozen Rails books, it'll be hard to compete with the authors of this book: Dave Thomas, who wrote the preeminent Ruby textbook, and David Heinemeier Hansson, who was the brains behind Rails.

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.

Would have been 5 stars, but ...

Wait for the second edition. Ruby on Rails has changed very much.
If you (as of this writing) search for the ISBN (0977616630) of the second edition, Amazon will "find" the first edition (ISBN: 097669400X).

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.

Rails, or more appropriately Ruby on Rails is the new web application development framework that everyone is so excited of and raving about how it cuts development time by a factor of 10 and does away with the cumbersome XML configuration files that are the hallmark of J2EE.

Being an old Java hand, I wanted to see firsthand if there was some substance beneath all the hype. I was also intrigued by the fact that many other old Java hands whom I respect and admire, like James Duncan Davidson, Elliotte Rusty Harold, Bruce Tate, Graham Glass, and Brian McAllister are now fervent (to different degrees) rubyists and Rails-enthusiasts. If it weren't for them, I would never have undertaken this journey, probably.

But anyway, this is supposed to be a book review, not a chronicle of my ongoing discovery of Rails.

I mostly like using books to discover and learn about new technologies, so it's perfectly natural that I decided to take off with what is considered the book about Rails. And how could it be not, with Rails' creator David Heinemeier Hansson as one of its authors?

It is also the only one published so far but, even though the choice was a bit, uhm ... limited, I wasn't disappointed. The book, as is customary with titles from The Pragmatic Programmers' bookshelf, is very good. It lays down in detail almost everything you need to know to be productive with Rails, save for the language Ruby itself. To be honest, the book includes an appendix introducing the basics of Ruby, but it's just the bare minimum. I suggest getting yourself a good Ruby book (like Programming Ruby, also from The Pragmatic Programmers, which I am currently reading and will review shortly) if you really want to get the most out of Rails.

Another caveat you have to be aware of is that Rails is a quickly moving target. The book covers version 0.13, which was current around mid-2005. There was a 0.14 version after that and we are now at 1.0, since a few weeks ago. However, I didn't find I had much to change while experimenting with Rails following the book. As always with Open Source software, resorting to the mailing lists, forums or the #rubyonrails@freenode.net IRC channel is the best avenue for finding answers to your doubts and asking support questions.

The book is organized in four parts:

Part I introduces the design principles behind Rails, its most important concepts and briefly covers how to get started by installing it and writing your first program. The part about installation is the one that is bound to become quickly obsolete, as new and easier installation methods for the various supported platforms are developed.

Part II dives into Rails by guiding you along the development of a real (albeit much simplified) e-commerce application. I find this approach to be very good and "pragmatic" indeed. Of notable interest is the chapter on testing. It's great to see that providing a good test scaffolding was one of the main design concerns in Rails and not just an afterthought.

Part III goes deeper into Rails and can be used as a reference for its components, like Active Record, Action Controller, and Action View. Bonus chapters on AJAX, Web Services, security, deployment and scaling issues are included here and will make the book even more valuable when you need to deal with "real world" applications.

Part IV contains the appendices, like the above mentioned introduction to Ruby, a reference of configuration parameters (be warned again: these might change), the full source code for all samples (of dubious value, in my opinion), and a list of online resources (once again, a list bound to be more and more incomplete as time passes and the excitement around Rails grows).

Overall, I find the quality of this book to be excellent. It's not thick to the point of being too heavy to carry around in your laptop bag, for those times when you need to peek at it, yet it covers enough of Rails to be considered a complete and authoritative reference. This is probably a testament to Rails' simplicity too.

The writing style is eminently readable. You can read it cover to cover, if you like, without getting bored. The frequent sidebars make it lively without being too distracting. A great amount of care and craftsmanship went into producing this book, and it shows.

Highly recommended!

I just finished researching and assessing the use of Rails (a.k.a. Ruby on Rails). The primary technical resource for this research was the book, Agile Web Development with Rails by Dave Thomas and David Heinemeir Hansson. As you probably already know, Dave Thomas of Pragmatic Programmer fame is a delightful writer and David Hansson is the guy that created the Rails framework, so I expected the book to be good, but not this good.

In my opinion, this is one of the best development books I've had the pleasure of reading in a long time. I found myself reading almost the entire book - which is unusual since I normally can't get past a few pages in most technical books before labeling it crap and putting in the circular bin. (I do not donate those books to the library because I don't want to encourage their distribution).

In my opinion, Rails is a really important lightweight framework for developing green-field web applications that don't require the heavy lifting associated with 2PC and support for legacy systems. If you want to be on the cusp of the next frontier in web and enterprise development, you should start with this book which will introduce you to Rails, Ruby, and a new way of thinking about web development in the enterprise.

If you do web development of any sort, you are going to want this book. And once you have it, you're going to want to keep it on your shelf right next to your desk for years to come.

I'm not going to talk up the ruby-language, it's been done better for my at places like http://ruby-lang.org/ The language has many strengths that are expressed in this book.

But what we're here for is Rails - This new framework that has the potential to change web applications for the better. I work primarily with PHP because it cuts down on development time, it very powerful, and has a lot of built in functions that pave the way for some great applications. However, there's a problem with these PHP apps. They are usually just hacked together, and once it works, it works. There's a lot of tedious work involved in getting everything going, and while the control over the whole program is great, you find it easy to get lost in your PHP code while you're just wanting something to work correctly and hope to god that your client doesn't change their mind at the last minute and leave you stranded.

This is where Rails makes it's presence known. The ultra-flexibility of the framework makes changing, expanding, and improving your applications easy as pie. Easy, but not as tasty. And this book does a great job of walking you through what you can do with real life examples that are easy to follow and actually work (how many of us have got a programming book before only to find out that some things don't even run when typed verbatim from the text?).

Dave Thomas keeps to the Ruby mantra of making programming fun again. The style of writing used makes for a very easy read and feels like an adventure into programming something new. You get to build one step at a time, see what it does, some more is explained, and then there's another small adventure. This is unlike other programming books (especially the PHP and JAVA variety) where a good lot of the exercises is just typing html output (or whatever output) a few pages at a time, followed by a boring 2 page explanation about program variables and memory placement. If you are sick of books that feel like tedious work just to learn the language, this will be a refreshing surprise for you.

So why am I giving it 4 instead of 5? Because it's not without fault. First off, it claims it's for beginners (or near-beginners) to experts. Yah, right. Because so many things in this book are glanced over quickly as far as the back end of the language and what you're really doing, if you don't have a handle on certian concepts beforehand, you're going to be very lost very quickly. Also, unlike PHP, ASP, or JSP which is a pretty easy and simple set up on your OS or on your webserver (where PHP is probably included if you're paying for hosting somewhere), Ruby on Rails is a little more hands on. If you aren't good at (or at least familiar with) a command prompt, that can be a whole new adventure by itself. Also, you're going to know how to work the mySQL command line at least enough to create databases, add users, make tables, etc. Plus the basics of programming languages and control structures should be something you'll already know coming into this book. Be forewarned, Thomas shows no mercy, the first real programming chapter makes a hello world app and then adds the current time to it. Nothing too heavy here. But then it's "ok, now we're going to build a shopping cart application". Granted he takes it slow and goes step by step, but there's none of the "This is a variable" and "this is how we call a function" stuff you're akin to seeing in these kind of books. Which can be good or bad.

If you've already got some programming under your belt, you'll appreciate the get-down-to-business style that this book takes, but if you're still in the infant stages of programming then this book may just do more harm than good. It all depends. I suggest going to Barnes and Noble or any other local book outlet, picking it up and reading some of it over, if it looks like it's too much, wander over and pick up "PHP and MySQL Web development" and start with something like that. But if it looks like something you could get through and have fun with, run home, go on amazon, and pick yourself up this book.

And by the way, Welcome to The Python/Java/PHP/PERL Rehabilitation Clinic.

I have been developing web applications since ever. I recently decided to get on rails after seeing the videos at rails web site. I have to admit that I was a bit curious if rails was another MVC framework written in a fancy language called ..umm Ruby I guess.

I got questions. Is Rails really as hot as people mention? Is this language called Ruby worth investing in? Would it fit my requirements for large web applications which I prefer to use Mason over PHP?

I got all my questions answered. First of all the book is very well written. The authors get you on the rails and guide through development of a full application before doing anything else. So this lets you get familiarize with the environment and also help you acquire basics of which editor to use, how to see the results, how to layout your desktop.

After developing your very first guided application, the book introduces you the foundations of Rails. One of the best things about this book is that it does not feel like a reference. Each chapter, along the way includes examples, and more important warning of common error which you will surely make. If I had skipped ahead I would have done lots of head banging. The warnings are very well placed.

The book covers lots for advanced features you would not expect in such a book which includes SQL injection, precautions for parameter mangling, scalability and deployment.

To be honest, I knew nothing about Ruby and still not read the Ruby book I bought along with this book. If you are a Perl developer, you'll almost feel at home with Ruby.

So, having bought this book one week ago, I had to make a choice for an upcoming project which I have to deliver in 4 weeks time. I made a bold choice and started with Rails. The project is due 2 weeks and I'm almost finished, seriously. It would take much more time with Struts or Spring. I also must add the customer satisfaction of iterative demos.

One final note. Rails support an extensive set of test driven features. The book presents how to write good tests both unit and functional on the project it guides you to develop. I was amazed to see that I was able to actually make requests from controllers, easily parse results to test the flow of my web application.

Bottom line, I found Rails to be very productive for me and this book made me almost finish a real world applications which otherwise I'd still be very far from even the half.

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.

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.

This book has undeniably ignited the enthusiasm of veteran web developers, but it simply cannot be considered a manual for the absolute novice.

As a casual hobbyist, I had high hopes for "Agile...", and for the Ruby on Rails framework generally. I should have heeded, instead, the "Agile.." introduction, which describes the text as a means of allowing professional web developers to become more efficient at their essential tasks.

I'm in no position to judge whether the authors' claims are accurate in this regard. However, I can say with certainty that "Agile..." is no 'for dummies' book.

Beginners should beware the extravagant claims of some reviewers who describe the "Agile..." book's flagship tutorial ('Depot') as a weekend project. I found it extremely time-consuming and, despite being peppered by textbook-style bullet-points, regularly lacking the most essential, big-picture explanations. Diagrams, for instance, would have helped immensely.

This is especially true when, during the Depot tutorial, readers attempt to understand the interaction between files and the folders in which they reside. If beginners find the deceptively simple system rapidly devolves into a conceptual morass, as it did for me, they cannot, perhaps, be faulted. Neither can they expect an easy rescue.

While I found this book extremely disappointing, it clearly ranks as one of the essential tomes for Ruby on Railers. The explanatory narrative and friendly prose are engagingly informal. The authors have diligently formatted chapters into sections which make sense and are clearly delineated. These enticing qualities should not deceive amateur web-enthusiasts. Keep searching for some other, simpler, and more complete book.

If you're a web programmer, buy this book right now. Do it. Now.

Rails has been hyped a lot, so I won't add to it. I'm just gonna tell you what I know from working with it myself.

You know how pretty much every webapp has to do the same things, over and over? There's a template system you have to set up. There's session storage. There's almost certainly a relational database, and you have to work with its data in your business logic. There's forms, and input validation. I could go on and on.

Rails helps you deal with this repetition of code in two ways:
1. It gives you great code to do many common tasks, out of the box. Some, like sessions, just work, with literally zero configuration needed. Others need a line or two. If you'd like, you can write your own code - roll your object-relational mapping layer if you really feel like punishing yourself - but if you don't have legacy systems to talk to, it's very easy to use the wonderful built-in code.

2. It provides a well-structured framework and set of tools to let you focus on writing your business logic, rather than the mechanics of getting the code to run. Grunt-work is almost nonexistent. Example: rather than needing to explicitly call for a certain template to be displayed, Rails defaults to the template of the same name as the current action. That's only one line saved, but it's more flexible - rename files, and nothing breaks - and the savings really add up.

Note the common thread between the two: providing you with the basics out of the box, so you can focus on your business logic. Rails, and the larger Ruby community, places a very high value on programmer time, and so it'll try to save you from writing "obvious" code or repeating yourself. It does a darn good job.

People in the real world have seen twenty to one code reduction going from J2EE to Rails. Twenty to one. Think about that.

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!

Rails is a fairly new technology (2004) so there are not a lot of options out there to learn how to use and program web applications to use this exciting new ability to get web applications up and running fast and with high performance in mind. Luckily we have just the book to solve this problem of how to learn Rails and get your site up and running in no time thanks to "Agile Web Development with Rails" written by Dave Thomas and David Heinemeier Hansson!!

Simply put, Rails is a new way to output dynamic content on a web site, similar to ASP and PHP. The thing that is great about the Rails technology is the ease of use once you have the framework installed, and the power that comes out of the box. With Rails you can make database connections with ease, and write code to do everything from the simple action of just creating/using variables to highly involved code that has flexibility and functionality always in mind.

The format of writing code that uses Rails looks very different from your ASP environment that most web developers are probably familiar with, but the learning curve is not very steep. You should be able to quickly make the transition to using Rails by using this guide which is structured very well and provides many pictures of the output generated as you go from one page to the next.

The author begins with the premise that he will be making an online store site, and slowly builds the site from the ground up, showing how code formatting is generated, SQL connections and database usage is put in place, and goes on to talk about profiling, performance tracking... the whole enchilada!!

This is a fantastic reference for anyone that wants to learn more about Rails development or is undertaking actual production of a site that uses Rails as the server-side framework. For such a new technology it's refreshing that such a great guide is already available for the public.

***** HIGHLY RECOMMENDED

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 is a great tutorial that also serves as an OK reference. The sample application (an online store) has just enough size and complexity to serve as a good introduction to rails.

The typographical conventions were distinctive and well thought out. For example, references to the short Ruby appendix are shown as very small topic/page number references in the margin, thus not interfering with the chain of discussion for readers that don't need the ruby information. Code snippets are identified by a file number, in the margin, and there's an index of file number to file path in the appendix. Again, this gives all the necessary information without interrupting the flow.

This is the first computer programming book I've been excited about in years. Mostly that's because rails is such an amazing framework; but the authors did an excellent job of conveying the essence as well as the details of rails development.

Very good book for learning Rails. There is not much focus on the details of Ruby, so if you are new to Ruby AND Rails you'll also need a book on Ruby.

The book takes a two-part approach to describing RoR. In the first 8 real chapters (5-12), the Daves use a gradual build-up a storefront application with incremental and increasingly complex functionality to show RoR's capabilities and flexibility. Walking through these helps you get some hands-on experience with the framework. The next 10 chapters go through the various aspects of the Rails framework and describes how RoR does its thing. Besides the core functionality, the book also covers Security, Caching and performance, and testing.

A good framework lets you do the most common things easily (do simple things simply!), while also letting you override the default behavior to implement your own logic. I appreciated this book's approach in following this flow, first showing you how to do simple things, and then explaining how to bypass or override parts of the framework's assumed formalisms.

I bought this book in tandem with the Programming Ruby book, having been away from programming for many years and not knowing Ruby at all. I would recommend that you at least get acquainted with Ruby first, but after that, it's an easy read. I developed my first basic AJAX app using RoR in little time, mainly using the book but sometimes needing to go to the web for more info.

I haven't read any other books on Ruby, but for an introduction to RoR, this one is very good.

I followed the Rails hype for a while, turned off by the Ruby syntax.
Yes, it looked like Perl had risen from the /dev/zombie.

A couple of friends had written some apps in it and I've never seen them this excited before.
So I had to look closer. My friends were right, as full time java developers, there are a lot to "get" from Ruby and Rails.
Rails is set of libraries to write web sites with database backends.
For web apps written in the MVC pattern and table-backed models, I don't think it get any better than Rails.

This Agile book spends a couple of chapters on a fictious but informative session between a programmer trying to solve a job with a customer.

Rails almost-zero-configuration "syntax" is described pretty detailed.
Again, as a java developer, you just sit there nodding, thinking how you'd (have to) solve it with j2ee.

The mid and last chapters talk about unit testing and common sense around scaling issues and web security (such as sql injection).

Even if you don't end up writing more than a test app in Rails, those last chapters are a good read.
Pick this book up if you have done web development in other frameworks before and are curious about Rails.

If you continue using Rails like I did, it's a good reference book.

I have been wanting to do a project on an official MVC architecture for some time now. In my own free-range PHP coding I have attempted to use MVC principles by templating (views) and segregating all implementation code into classes (models) but of course this relies on strict self discipline. On the other hand, I have seen some MVC systems that are extremely rigid and limit what you can do to certain well-known models. Nothing I do ever conforms to well known-models, because if it did I probably wouldn't do it.

Let's see what Dave and Dave can do for me. The first section of the book is organized as follows: Chapter 1 introduces the book, talks about what is Agile, and gives the typographical semantics. Chapter 2 gives a nice little schpiel on what is MVC. Believe it or not the theory has been around since 1979! Chapter 3 is the "How to install Rails" chapter, and Chapter 4 sets you up with a "Hello world" app. The instructions are easy to follow, and I did everything like it said, and everything seemed to work, until Hello World. I could not get the WEBrick server to serve up the "Hello world" page on my Fedora Core box. I understand it is quite a pain to make Rails talk to Apache so I won't even go there until I have something for production. I was able to use a UML instance remotely. So although I have no desktop and it's very slooooow, Rails installed there with absolutely no hassle and works like a champ. The installation section of this book needs a bit more distro/platform specific troubleshooting, and I don't think they should even mention Apache at this point.

On to Chapters 5-11: building an app. This part of the book really shines. In a chatty, casual and ideally agile style, they guide you through building a simplified shopping cart app from scratch, illustrating general Rails principles as they go. You can follow along by downloading a glomp consisting of the tutorial examples versioned by chapter. This style of tutorial best suits my personal learning style.


Then we get to Chapter 12 on tests. Rails generates the skeleton of the test and the test suite for you automatically. You still have to come up with the tests and the assertions, and the hardest part of all is the fixtures--that known state from which you can predict what should happen when you do X. Fixtures are especially hard with a data driven application where the dataset is constantly mutating. The long and the short of it is: You need a totally virgin database that you put the same carefully concocted initial data in when you run each test. Rails has this baked in: Each rails project automatically builds itself a dev database, a production one, and a testing one. You test every little thing at the micro level and you run the tests over and over. If something fails, it helps you get to the source a lot quicker. If you didn't have these tests, problems could propagate into far flung sections of your application and you have to painfully sleuth out the cause of them. Been there. Done that. I'm a believer.

In practice, I fired up the unit tests right out of the examples and they borked all over me. Turns out there was a fundamental non backwards compatible change in the way they work... But finding Mike Clark's blog was tremendously helpful. Following his instructions, updating the database and the tests to the new way was easy, and after that they worked like a champ.

After Chapter 12 on testing, the book becomes more systematic and dry--like other technical reference books.
Chapter 13 fills you in on the structure of rails. 14 and 15 systematically lay out the correspondences between the Active record class and RDBMS concepts. 16 explains the logic behind rails magic, and takes a look behind the scenes. 17 fleshes out the presentation (view) layer of the MVC trinity. 18 touches on Ajax, 19 is about Email the rails way. 20 is all on Web Services. What would a web programming book be without a chapter on security (21) and 22 talks about scaling out and real world issues. Finally we have Appendix A that introduces the Ruby language. This inclusion was invaluable for me because I did not know Ruby previously. The other appendices are useful as well: B is a list of the configurations, C is a list of the source codes for the Depot App, and D is resources and Bibliography.

Errors: I am holding the first printing in my hand. There have been two more since. They believe in frequent updates and small runs. Pragmatic had an errata on their website and man was it large--so large it was hard to use. I wish the errors would have been filterable by severity. But without it I would have sunk.

All in all, the book was a positive. Building the depot app gave me hands on with the concepts so that when I later come along and read the dry complete reference part it will be attached to something I've done. I totally recommend the book, but get the latest version.

This is a must read book for any career developer. It will give you ideas for your existing work, and inspire you to try out Ruby and Rails.

I thought I had seen the best from Dave Thomas with the Pragmatic Programmer and the Ruby pick-axe book, but this book tops both. It's well thought out and organized. The writing is engaging. The technology is well researched. The examples are great. Illustrations are sparing, and used effectively.

I can't come up with enough words to say how much I love this book. This is easily the best tech book this year. It's a must read. It's a tour de force that shows how good tech books really should be.

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've been a software developer for 19+ years, and have been teaching hundreds of programmers for the past year on a wide range of topics...and hands-down...this is the best learn-how-to-program-in-whatever book.

Most other tech books follow certain patterns to get their point across

* deliver concepts in small chunks followed by short samples
* preach endlessly - and then end with a big code-dump
* all text - little code
* too much code - not enough text
* etc...

"Agile Web Dev with Rails" gets the right mix. The first half of the book builds a Shopping Cart application with Ajax features (and even administration screens and REST web interfaces). The second half of the book provides a solid overview of Rails. So you get two books in one -- a great tutorial, and a great Rails reference.

And the tutorial portion is written in a way that you feel as if the author is sitting next to you while doing the exercises. You can hear his thoughts about why certain things are done, or certain code need to be refactored. Using Agile development techniques where the requirements can unfold in real-time, it even sends you down paths only to back-up a few steps once a better-way is discovered (or the mythical client steps in and says they want it done a different way).

[...]

But if you're serious about Ruby on Rails -- just buy the second (current) edition of Programming Ruby along with this book. You'll be glad you did.

...Highly Highly recommend!

Rails is a great web development framework. It makes Java web frameworks look silly. The book is an easy read with great examples. I will be using it to help write our new web frontend of our next product.

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.

I read version 1 of this and have already read this version (pdf early release). I use this book everyday at work where I work with rails.

You simply can't go wrong with this book - The 3 chapters on ActiveRecord
are worth the price alone.

In all my years of reading, using and reviewing technical books, this is the first title I've read cover to cover, and in so doing actually built the sample application from start to finish. Most other books use a series of disconnected This book was my first foray months ago into the beautiful world of Rails development, and continues to function as the crowned jewel in my reference library anytime I have a question about Rails or Ruby.

The developer that gets the most out of Ruby on Rails is the experienced programmer with a diverse background (expertise in some programming language, database/SQL experience, server administration, etc.). This is the crowd that will appreciate the rapid development features of Rails, abstracting away many of the tedious tasks necessary to build stable, scalable, secure web applications, with a fraction of the code.

Dave Thomas pens a classic tutorial on building a practical e-commerce app, applicable in several diverse scenarios, and certainly helpful in its design of leveraging the capabilities of the web framework. There's also insightful contributions by Rails creator David Heinemeier Hanson, which helps for some of the more niche concerns experienced developer have likening Rails to platforms they may be more familiar with.

Each chapter is fairly succinct, teaching proper Rails software design, coding conventions, and incorporating OOP principles.

The book is essentially presented in three parts: building the sample app; learning best practices development on Rails; and a healthy collection of appendices that introduce Ruby syntax. While I didn't necessarily agree with the book's organization at first glance, it does make sense when you realize just how easy it is to setup powerful, automated systems with Rails learning in such a fashion. You'll get up and running with the easy stuff and then move onto the more advanced topics.

In criticism, I would have liked to see a more robust appendix of Ruby and Rails APIs (at least documenting some of the more popular properties, method and events), as well as a cheat sheet for the common command-line syntax used in setting up apps. I would also have liked to see a little more documentation about using databases other than MySQL, and perhaps a tad more of a discussion on MVC architecture, at least academically. It would have also been nice to dive a little deeper into working with e-mail and some of the more advanced XML features with Rails. True to the framework which is represents, the book does move at a frenetic pace.

But that aside, this is the best, easiest way to learn Ruby on Rails. This will be the best investment you've ever made into the open source market.

This book was hands down the best technical book I've ever read. Through some kind of magic voodo, the Dave Thomas has written a book that is accessable and enjoyable to read for both novices and experts alike.

For its tiny footprint, it covers everything you could need to know about Ruby, and the Rails framework. Its style is light and has just enough humor to make it fun without overdoing or making it hard to follow it like some other books (*cough*Programming Perl*cough*.) I really liked that their running example was a "real world" shopping cart rather then something very abstract like a "Gilligans Island" or some other silly nonsense.

Even if you have no interest in Ruby or Rails, and even if you think the whole platform is a bunch of overhyped rubbish (it is not by the way), you should still buy this book just to know what a good technical book should be.

I fell in love with Rails after trying it about a year ago, so I when I learned that DHH and Dave Thomas would be writing a rails book, I signed up for the beta right away. The finished product a fantastic introduction to rails, and if you're serious about learning it, there's really (literally!) no other choice. This book will be your constant companion for months.

But the danger with any computer book published before its subject goes 1.0 is that it will be out of date, and that's somewhat true in this case. Near as I can tell, everything in the book still works, but any new features added since 0.13.x are missing.

It's also a so-so reference. I find that plenty of times I have to go to the online api docs to answer a question that the book doesn't touch, or covers lightly. I suspect that will suit some people just fine, but I like a real, comprehensive dead-trees reference book. Perhaps now that 1.0 is here and the APIs are stable, we'll see something like that.

In the end, despite growing pains, this is one book any rails developer would do well to keep at the ready. Recommended and looking forward to the second edition.

I just read the first few chapters (and the last few) and I found it to be very, very good. I'm not about jumping on the bandwagon (I'm a Java programmer), but it is neat to see how someone built an MVC architecture from scratch and his detailing behind it. He tries to take everything in consideration and covers a whole lot in a well written book. I wrote my own MVC architecture for a Content Management System and a few other apps. I found myself wishing that I read this book a couple years ago while patting myself on the back for getting most of it right. Whether you use Rails, Java, or something else, I believe there is a lot of great philosophy here behind the Ruby/Rails code.

I enjoyed Dave Thomas' "Programming Ruby" which provided a great tutorial of the Ruby language and and excellent rundown of the language itself, topped off by a useful API reference section.

His "Rails" book is light by comparison. Its a great tutorial, but rather incomplete about the Rails framework in general. I have difficulty using the book as a reference for my particular project and problems. The API is available on-line, but doesn't give the insight for someone still learning Rails.

I wish the book had more information and advice on developing more robust applications, and working with more complex data.

My programming experience is mostly with mighty PHP. I read some comments about Ruby and Ruby on Rails and got interested. Bought both books. If your field is web development, Ruby on Rails is a must read, mind blowing programming book. You can start with Ruby on Rails and read the whole Ruby later. As a web developer it is your responsibility to learn Ruby on Rails, even if you won't be using it.

There aren't many (any) other books on Rails development currently, so this book has a sigular distinction: it's the only option.

Somewhere in this book is all the information you might need to get a good foundation going in Rails development. The writing is nice and easy on the brain.

But, the organization of the book didn't really appeal to my particular learning style. I wasn't so interested in continuing work on the very basic shopping cart app that is the "tutorial" in this book. I was more interested in things like working with complex, multi-table databases.

The book has sections devoted to Active Record, but these are often void of any working examples. There are often code snippets in these chapters, but they are free floating and out of context; in other words, the small snippets show you how something might work, but there is no place that shows it working in context.

Overall, I think this is a decent intro to Rails. But I would rather have a Peachpit Press type book, with straight forward code examples used in context. That's just a personal viewpoint, and you very well might think this book is a 5 out of 5. For me, I'll give it a 4. But I would still urge you to buy it -- it will prove a valuable reference as you find specific questions to look up.

After reading many online article about Rails I was left with mixed feelings; does Rails help with creating real web applications or does it simply make it easy to create "hello world!" with a database backend? Thankfully, "Agile Web Development with Rails" answers most of my questions about the platform and has proven to be an outstanding tutorial. The first part of the book walks you through the development of an online store. I was struck by the logic and elegance of the development process. The authors have clearly programmed in the trenches and understand the needs of web application developers. The latter part of the book serves as a reference to the components that comprise the Rails framework. It is in the reference section that the material goes way beyond any of the online articles about Rails. Whether or not Rails becomes the Perl of Web 2.0 remains to be seen, but it clearly points the way to a development process that I like very much.

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)

I have this book and some others and this one by far is the better book. It works at a good pace and answers a lot of questions in sidebars, just as your were thinking of them.

I did go back and get Ruby for Rails to strengthen my Ruby knowledge, but with these two you should have a firm foundation for building Database enabled Web applications.

This is by far one of the best, most usefull books I own. I would recommend buying this book along with the Ruby pickaxe book. Together both books have brought me hours of fun and a few cool projects that I have used for school. Definitely a must have. I went from no previous database knowledge to developing a medical records database overnight. Very solid book, brings you from the ground up to the sky. There is no limit, only those imposed by your imagination. Check out the entire Pragmatic Programmer series, they are truly unlike any other series of technical books. It seems as if the writers have tailored the books to the completely nubile programmer, yet every section is packed with the juicy details that keeps even the most hardened programmer interested. must buy.

I just read the beta version of the second edition cover to cover in just a couple of days, and I love it, the content as well as the exposition. The first edition only gets four stars, though, because the second edition contains a lot of updates worth waiting for. Even in its rought beta state it's a great resource, and I'm looking forward to seeing the finished book.

When trying to do a book on the combination of the two I don't like it. I purchased this book because it was one of the few books on Ruby on Rails available. I certainly understand how Rails and Ruby benefits the Agile developer. Unfortunately I was looking for a more traditional technical book on a single technology topic, not two put together.

Once I got over that the book was fine but I have read better books and I have read worse.

Having read "The Pragmatic Programmer", I knew I would not be disappointed buying a book written by Dave Thomas. Add to that the fact that it is co-authored by the creator of rails, buying the book is a no-brainer. Four other experts have contributed a section each as well.

It didn't expect to see a book on rails out so quickly -- rails being a fairly recently developed framework. But then, with the authors being advocates of agile practices, its hardly surprising.

I was drawn to Rails after watching the fifteen minute video ( www.rubyonrails.org ) showing that you can develop web applications very quickly. Having gone through configuration file hell in many projects, the Rails philosophy of favoring convention over configuration makes a lot of sense. This will be a great framework to put together a quick and not-dirty prototype that can evolve into a final product.

I am about half-way through the book and it is a hands-on tutorial from start to finish of iteratively building a nearly full-fledged ecommerce web application. An added bonus is that the authors continually inject sound programming common-sense and agile programming practices while going about familiarizing us with rails. Even if you are never ever going to use rails it is worthwhile going through this book just for this reason.

The "form" in which the material is presented is also excellent. Code snippets are cross-indexed to complete source code in an appendix so that you can easily establish context without disturbing the narrative flow. The style of writing keeps the reader in control with unobtrusive pointers to help if needed.

The wisdom that will be imparted will be relevant even if you are stuck in the slow and "standard" world of J2EE. You could still use Rails to build quick prototypes.

Buy this book -- and if you can, also buy the "Programming Ruby" book. The first edition of "Programming Ruby" is available online -- so if rising gas prices and the like are causing a cash crunch, I recommend buying this rails book and falling back on the online documentation to learn and master Ruby.

This book has a great introduction and tutorial for understanding rails for the beginning rails developer.

However, you may find that a considerable amount of the code in the tutorial does not work with Rails 2.0! Things like pagination and the original scaffolding methods have changed. Nevertheless, if you search through Pragmatic's forums, you may find assistance to help you understand the tutorial through the 2.0 perspective.

Now more about the tutorial itself. It's action packed and the book does a great job to help you dive right into it. The beginning chapters are basic walkthroughs with Rails Playtime in the end. Rails Playtime are tasks that you can try on your own and are absolutely fantastic for getting more grasp on the material. Answers are even available online.

Although a little outdated, Agile Web Development with Rails (2nd Ed.) has been and probably still is the best beginners tutorial for Rails out today.

There's not much more you can say than this: you need this book if you're working with Ruby on Rails.
Of all the technical books I've read (and that's a LOT), only 2 more struck me as being this exceptional: "Graphic Java" by David Geary and "JavaServer Pages" by Hans Bergsten.

I'm more often than not disappointed by books on new technologies. Agile Web Development With Rails is impressive. The tutorial works as described--which is extremely important--and each step is presented in simple, straightforward terms.

My only complaint is the small, grey filename that precedes the code listings--it's not the easiest thing to read.

If you have the first edition of this book, you REALLY need to get this edition, since some of the recommended ways to do things have changed. Even some of the ways to get the first sample applications up and running have changed a bit. To be sure, the changes are for the better. The first edition of this book helped me to get my first Ruby on Rails app up and running and this one makes it easier.

This book is a great resource for newbies to Ruby on Rails. Actually build a working product and learn while you do it.

nothing to say, the book is awsome. and the Amazon with the delivery too. and now im waiting for the Programming ruby book, (bought in amazon too).

Is the best book of ruby on rails. the best to begining!....

Edit: With the release of Rails 2.0 this book is too outdated to be of much value.

First off, if you want to do some dynamic web design RoR is definitely the way to go. Many languages and frameworks claim to handle the messy details so you can work on the application, but are exaggerating, at best. RoR delivers that promise. If you have a little programming experience, you can rip through the first 5 chapters in an hour or two, and have something useful built in very short order.

This book is well written, it is clear and lets you do some fairly impressive things early on, with little effort. The problem is that so many important details are glossed over. Perhaps rails is so good that it hides too many details. It is possible to write a non-trivial application using AJAX, XHTML, mySQL, and of course ruby, without actually understanding any of them.

Maybe this is a good thing, but I am of the school that thinks that a programmer needs to understand the underlying ideas to effectively leverage the higher level API's. But it is very impressive that it is possible to create non-trivial applications without a solid knowledge of Ruby. Try using JSP without understanding Java!

This approach is good for a beginner, because she isn't spending weeks doing lame hello world type projects, but it will also limit what they can do, because they will be tied to scaffolding, and if they ever need to do something in another language, they will be lost there also.

It is maddening for people with some programming experience because they are asking questions that the book doesn't answer. But it is still useful and enjoyable, it gets your feet wet and puts you on the path of creating good rails applications. The book also at least partly tongue in cheek, explains some things away as magic. Things like this make it hard for me to take this book seriously.

I would love it if they created two books out of this one book. One for beginners, and one for more experienced programmers. Books that cater to both often leave one of those two groups in the cold on any given page.

The deployment section is too narrowly focused, and another 30 pages or so would have been more useful to more people. It also points out the main problem with Rails, IMO. It can be difficult to effectively deploy apps on production servers. Not that JSP containers are much simpler, no crappy XML config files to wrestle with and you don't have to install a full blown server like you do with JSP to test on your machine. WebBrick is a very small and very efficient testing platform.

Another major problem is that much of the code examples simply do now work. A lot in the CRUD sections fail, there is not nearly enough information on using SSL in rails, the has and belongs to many examples, etc. Some of these problems may be due to the ever changing nature of rails, but not all of the problems.

Still, this book is a great introduction to what I hope is a framework that will take hold and grow over time. I have no idea how well RoR scales in enterprise projects, but at least for basic and some not so basic web applications, nothing comes close to Rails.

Despite my grumbling, I recommend this book. The first 12 chapters are an excellent tutorial, the remaining book is boring and often misleading or wrong. If you want a serious treatment of this topic, try The Rails Way.

Very good book for learning rails. The only problem I have with it is that it doesn't get too in-depth with why things work and how they work, it just says that they work --this way-- and how to actually use it.

Don't get me wrong, this is a VERY good book. I would recommend it to ALL rails starters. I just wish that it was DOUBLE the size and had this book in the beginning and then a more in-depth behind it. I just ordered ruby for rails thinking this should fill in the whys.

There are mostly good Ruby books out there now. There are lots of so-so Rails books, none really bad, but this is the place to start with Rails.
After this, get Ruby for Rails.

But when using this book, know that you do need to visit the web site of the authors and they do answer emails personally. They also maintain updates to the pdf version and errata on each print and pdf version. They really have put time and effort into making a good book for learning. It isn't perfect, but it's definitely one of those really well-crafted things that are rarely written by computer people for anyone.

DT is a heck of a good communicator or something

This is one of those books that should be in every Rails developer's library. It is a centralized, consistent, and up-to-date reference packed full of useful examples and tips that will save you a lot of time when learning and developing. I can't tell you how nice it is to look something up in the index and read about it instead of searching the net for hours to find scattered and incomplete information.

The book presents itself on a easy language and introduces the core concepts of Rails 1.2 during the already famous "shopping-cart" example.

After that, it explains each of the components and their uses.

Very good even if you're not into Ruby (yet ;))

I bought this one with 'Programming Ruby' thinking that I would need both to understand what RoR is all about, but 'Programming Ruby' is still on the shelf and in a few days I was running the shopping cart example. Great way to learn how to use the framework. And from what I saw, the new version is evolving at the same fast pace as Rails. That's my next buy.

I won't repeat what others have said but the fact that it was a joy to read the book. The writing style was definitely entertaining and informative and for anyone who wants to jump into RoR programming, this SHOULD be the first book to read. I come from a J2EE development background and skeptical at first but this liberated a lot of my biases against RoR.

If you're like me, you like to have documentation at your side when using a new language or framework, and well, this was the only thing available so I got it.

Frankly, it does a reasonably good job of explaining Rails basics and even goes into some production server setup issues and configuration ideas. I think what I was really looking for was more like a Rails reference book, which this is not -- This is more like a "learn rails in 24 hours" except the difference is you actually CAN!

Well written and a good collection of issues addressed. Basically its a must-have.

Rails may be wonderful, and once you know it you may indeed be able to slap to gether amazing applications in 16 minutes, but it is definitely not easy to jump into. If you're already sailing along writing Rails applications, the book is probably still valuable as a reference, but if you're just getting started or interested in starting, just buy the book. I usually try to get along with online documentation but in this case the book has been a life saver. And buy the Programming Ruby book, too, you won't regret it.

I do hate reading computer language book's, i just use them as consulting guides. Butthis one is different. It's easy to read, and in one week you'll have read it till the end withount having noticed.

It's also a good starting point for those wo don't have an idea of web applications programming. From the veri first page you will be able to do useful things (not that crappy "hello world" only, you'll be doing really interesting things in no time).

This book has been wonderful. It goes into detail on all of the aspects of Ruby on Rails and builds an example web application using quick iterations to build functionality. I feel confident that I can jump into Ruby on Rails and be productive right away. I definitely recommend this book.

Are you easily adaptable to change when it comes to your web applications? If you are, this book is for you. Authors Dave Thomas, David Hansson, Leon Breedt, Mike Clark, Thomas Fuchs and Andrea Schwarz, have written an outstanding tutorial and a detailed guide to Rails.

Thomas, Hansson, Breedt, Clark, Fuchs and Schwarz, begin by discussing why Rails imposes some fairly serious constraints on how you structure your web applications; and, how these constraints make it easier to create applications. Next, the authors show you how to install Rails, Windows, OS X, and Linux. Then, you'll get a glimpse of the Rails applications work. The authors continue by showing you how to create simple maintenance pages, link database tables, handle sessions, and create forms. In addition, you'll also learn how to create the web interface that lets you maintain your product information--create new products, edit existing products, delete unwanted ones, and so on. The authors also focus on how to create a simple catalog display. Next, you'll learn how to implement the shopping cart functionality. Then, the authors show you how to implement the checkout function. They continue by showing you how to fulfill orders. In addition, the authors also cover how to access the administrative functions. The authors also show you how to write automated tests for the application you all know and love--the Depot application. Next, they discuss all of the high-level stuff you need to know to understand the rest, like: directory structures, configuration, environments, support classes, and debugging hints. Then the authors look at the basics of Active Record--connecting to databases, mapping tables, and manipulating data. They continue by looking at ActionController and how it works within Rails. The authors also show you how the Action-View module encapsulates all the functionality needed to render templates, most commonly generating HTML or XML back to the user. Next, they discuss the Web, version 2.0. Then, you'll learn all about Action Mailer, which is a simple Rails component that allows your applications to send and receive e-mail. The authors continue by discussing how AWS is structured. In addition, you'll also learn how to secure your Rails application. Finally, the authors examine options that need to be tweaked and the software that needs to be injected as the development setting is replaced by the production setting.

This book isn't a reference manual for Rails. What it is, is an excellent book about how to use Rails modules and most of their methods, either by example or narratively in the text.

Rails is an MVC architecture for building web applications, similar to Struts and Tapestry. So why should you bother learning it? Simply put, because Rails provides a framework that makes it easier to build, deploy and maintain web applications.

Rails describes easier using two concepts from the agile development; Don't Repeat Yourself and Convention Over Configuration.

Adding new functionality using other frameworks inevitably requires making coordinated changes in a number of places. This requires you to spend a little of your focus on the tool instead of your application. With Rails, and the concept of Don't Repeat Yourself, every piece of knowledge is generally found in just one place. This makes web applications a little easier to code and a lot easier to maintain.

Another way Rails makes development easier is by providing usable defaults for almost every piece it provides. This is described as Convention Over Configuration and works remarkably well. Of course if your needs require, the defaults can be easily re-configured.

Rails includes lots of other goodies for the modern, agile developer, including AJAX and web-services support and a built-in testing framework. It's almost as easy to test your application by making web requests to the controller as it is to create unit tests for your classes.

The book is organized around building a working ecommerce website following an iterative approach. Each chapter mimics an iteration by adding new functionality, cleverly introducing new aspects of the MVC framework in a very natural order. I found myself focusing on building the ecommerce web application instead of learning rails. It's rare that I find a technical book so interesting.

It's a basic thing, but I liked the format of the chapters. Each chapter sets the stage with a paragraph introducing the theme of the iteration. Chapter sections focus on a single concept or task. The end of each chapter reviews what was completed. A common enough format, but done very well.

Whether you learn best by reading or by doing, this is a great book for learning Rails. I would recommend this book for anyone interested in quickly building robust web applications, whether for proto-typing or for use in production.

This is THE book for Rails. Top notch...only WAIT to buy it. As others have said, there is a new edition coming out soon that covers Rails 2.0. Of course...if you can't wait, go to the publisher's web page. They are selling copies of this edition for 50% off, while supplies last. But, some of the code in this book will not work anymore in Rails 2.0. Still, a great book and well worth it even for a quick introduction to the Rails world while you wait for the new edition. Once it's updated, though, for sure, GO FOR IT!

This book is a little outdated since Rails 2.0 was released and some methodologies / functions are deprecated. I recommend rolling back your rails version to 1.2 to go through the examples in this book. It is a great learning tool to get you up to speed on Rails.

Easy to follow along, and does a good job teaching the fundamentals. The Depot Program, which walks you through making your very own online store, is an enlightening walk-through.

This book is great I used it in conjunction with online sources to construct my first database driven web app in no time at all It is a bit outdated now that rails 2.0 is out but you can still get a lot of useful information from it.

i've made my way through most of the book already and I really enjoyed reading it. It's got a lot of great advice and help for this noob. Rails is the language of choice for all the cool kids right now, so take the time to learn the basics now!

This book is not easy for beginners, but it is the most accurate and thorough treatment of RoR I have read so far.

This book is a really good inversion if you plan to start you "RoR" experience, the way the book is written is very clear and in a good order, so you can understand better what's going on as you go along.

Great book!

This books explainse everything that is needed to start building a Rails application, even if you know nothing about ruby. The Depot Example is a great guide of how to build a site with Rails

This book manages to keep the pace with the Rails' development and has most of the recent features covered.
I really liked the way it guides you through Rails' application development cycle.
Overall it's an excellent information source for any Rails' developer.

It is difficult to write a book that is useful to both first time users and advanced users. I bought this book without ever having used ruby before. I have since started training people in Rails development. I still use my well worn copy quite frequently.

David Heinemeier and Dave Thomas are the authors of this book. Heinemeier has created the Rails framework. Dave Thomas has written the Programming Ruby book and is one of the authors of the Agile Manifesto. I need to say more? Ok, I'll try...

First of all, be advised: you could read these book by knowing nothing about the Ruby language, but you shouldn't. It'll be hard, believe me. So before you start your adventure on RoR applications, learn at least the bases of Ruby. Well, you can read the Programming Ruby book, by Dave Thomas, it's a soft initiation.

Now, assuming that you have learned Ruby before reading these book, Agile Web Development with Rails is the perfect way to start playing with RoR. It's expose practical examples and have interesting comments, and tips, about all the Rails framework syntax (or something pretty close). Agile Web Development with Rails is very didactic, easy to understand, and comes with a lot of real examples. You will learn fast, you will learn right.

I appreciate this book for its engaging introduction to Ruby-on-Rails, and for the agile programming lessons.
A downside is that it seems to have more errata than you'd like; some code doesn't work, and I'm not knowledgable enough in Ruby or Rails to fix it.

Before you buy this first edition, note that the second edition is already out in beta for download, and when you buy the beta, you get all subsequent updates for that edition free.

This book was the first book that drawed me into Ruby and Rails. There is something alluring about how this book was written, or maybe the sleek programming language (Ruby) and the framework (Rails) themselves are so attractive that I were drawn into it.

This book is one of those rare technical books that is so light to read page after page, after each page, you know you have learn something good. When it is over, you just wish there could be just another chapter.

I was curious to this popular and fast growing MVC framework that everyone is talking about. I got this book in addition to a Ruby language book. It does what a MVC framework should do. It is not the best framework, it is just different.

This book teaches you Rails so that you have a solid foundation to start playing around and writing your own web applications using this MVC toolkit.

I think Rails is so amazing to many because it is the first MVC web framework they have used, as there are many others out there in various languages (like Catalyst in Perl).

This gives you the information so you can learn what everyone else is talking about. Nothing more, nothing less. Just be weary of the cult ;)

I'm only about 25% thru this book so far, but I'm amazed at the clarity of the text. The author somehow has an ability to explain the technology unbelievably well. I dont know if the simplicity of the Rails framework has anything to do with making it easy to understand, but I'm just amazed, at least so far. I'm not a Ruby person either, my background is desktop apps in Java, and the last time I did web programming was in 1997. Still, this book is very easy to read, not dry like most technical manuals, and explains the Rails framework clearly and easily. I would highly recommend it.

Overall this book is great. It gives a brief overview of Rails and the MVC (Model, View, Controller) design philosophy, then dives right into a good real world example of building a simple e-commerce site with a product catalog, shopping cart, and administration, it is refreshing to see a book give a decent real world example rather than an oversimplified one that really adds nothing, as many books do. After allowing you get your feet wet with the sample site it then continues to go into more depth, explaining how rails works under the covers and even delves into AJAX. The one weakness of this book is that it doesn't give you any background into the Ruby programming language, which is critical to understanding all the examples. You can get by initially, but eventually you get lost without understanding the programming language. There is an appendix that introduces the language, but it's too small to explain everything that you need to become proficient. They really should've devoted more time to Ruby since it is not yet a widely used language like C++ or Java. This book will definitely get you up and running with rails, but be sure to buy a Ruby book as well if you want to be able to effectively use the framework.

this book is a great walkthru of RoR and a must-have if you are planning on creating rails apps. you can't help but get excited reading this book, and once again, dave thomas proves he writes a great book.

buy this book (and the pix axe book) if you are getting into RoR

This book is a great intro to Rails, very readable and easy to understand. It also seems fairly comprehensive. The only downside to this book is that it's not Rails 2.0, so a number of the examples are outdated or don't work with the latest versions of Rails (there were significant changes). I was taking a class in Ruby on Rails, and since we were using Rails 2.0, we had to get "The Rails Way" which covers Rails 2.0 but sucks in comparison to this book. "The Rails Way" is a good book for learning Rails if you already know Rails.

I love the framework, the Agile philosophy and I love how the book is structured: straightforward, practical, easy to follow, programmer-oriented.
I truly recommend it for anyone willing to begin in the Rails universe.

This is classics!
I started reading it just to know what is Rails. I ended reading with absolutely involved and loving it!

I didn't know that Rails 2.0.2 does a few things differently than described in the book. Overall, however, I found it to be a great reference, and with a little help from Google and friendly souls who write online tutorials, I was able to create my own application while reading rather than following the example in the book.

I found the explanations on RESTful development somewhat terse and incomplete. However, the treatment of database access is very thorough. I did find it very useful to have my Ruby book nearby.

If this is the version you have installed, I'm sure there will soon be a new edition covering Rails 2.0.2, and given how much the technology is still in flux, it's probably worth waiting for it.

This is the second edition of the book and both are excellent. Of course there is no point in getting the old edition anymore. If you are looking for the fast track to learning Rails this is it. It walks you through the creation of a full featured website with Ajax scripting and all. Then the Rails framework itself is explained in a straight forward manner. If you get a single Rails book then I recommend this one.

Do a rail install of version 2.6.4 first otherwise the scaffolding doesn't work. How to install scaffolding with a new rails version is not explained. Very good tutor and introduction to Ruby on Rails.

I would recommend this book to beginner and intermediate rails users. The first half of the book walks you through building a very simple rails application to get some hands on experience then the second half includes everything you need to know about rails. The second half is an invaluable reference for me. Some prior programming experience will give you a huge head start but is not mandatory.

This book is awesome!

Ruby On Rails will be the mother of all programming languages!

This is an excellent book for someone who is new to Ruby on Rails development. You should buy an accompanying Ruby book though for those pesky Ruby questions =).

Of all the books I have read about ruby on rails, this is the most comprehensive and easy to understand, even without deep ruby knowledge.

Ruby on Rails is not just a locomotive moving on down the line. It is a bullet train moving at two hundred miles an hour. I say this because Agile Web Development With Rails is already in its second edition in only a year and a half. There has been that much change to the base framework to warrant an upgrade to the book in so little time.

What is Ruby on Rails - also known as Rails? It is a framework that makes it easier to develop, deploy, and maintain web applications. It uses Model-View-Controller (MVC) architecture as do many Java frameworks, but Rails takes it further in that it is almost as if you start out with the skeleton of an application already prepared. Rails is written in Ruby, a modern, object-oriented scripting language that runs on Windows, Linux, and Mac.

A couple of things I really like about the book and the publisher is that you can buy the book as a standard book as well as a PDF e-book. For a real discount you can get both. To me, this is a bonus since I like having the physical book to hold and read, but when I am working on something or traveling, I can still reference the material without locating the book. I also liked the detailed explanations contained in the footnotes. The authors do not try to overwhelm you with every detail in the dialog. Rather they are saying there is more information if you need it.

In my full review over at Blogcritics I found that at over 700 pages, Agile Web Development With Rails does a great job of taking you to the next level of Rails development. It provides you with a rich depth of information into the Rails framework and gives you the skills to bring your development to the next level.

Clear, easy to read as well as easy to follow.
If you're interested in Ruby on Rails, it's definitely a must.

I'm a new object oriented programmer (I only program for a hobby) and this book has been a great aid in my learning of Ruby on Rails. The book contains lots of useful examples and covers the various aspects of Rails in depth. The first few chapters provide a high level overview of Ruby on Rails. The next few walk you through developing a online store. The last several chapters cover Rails in depth, it also explains a lot of the concepts used during the extended online store example.

Agile Web Development with Rails (2nd edition) is excellent and I highly recommend it to someone wanting to learn Rails. However, I do have a reservation. The extended example is a bit simplistic. It covers enough stuff to introduce you to the different part of Rails that is needed to build a website, but it doesn't cover everything you would need to do to actually build a production website...though the rest of the book touches on some of the missing parts of the example.

Also note, the book doesn't teach you object oriented programming, but that is not what it is far. It does have a short appendix explaining Ruby. If you're a quick learner, you should be able to pick up everything you need without buying another programming book. Nonetheless, I think having another book to teach Ruby and Object Oriented Programming concepts as a reference guide would be of great help.

The book is to the point while still pleasant to read. It is the right book for the killer framework/application of 'Ruby On Rails'.

My personal recommendation is that it delivers the highest reward to mid-level and experienced developers from J2EE. Those guys will have an eye-opening experience of "how simple" web development can be, using the right tool. A beginner though should also refer to other sources, like HTML standards and articles on MVC pattern, before or while reading this book.

Great book, very detailed examples. I recommend it for anyone just starting out with rails.

This book is really cool, you really should read it.

This is a good book, although I do think that they ordered the chapters strangely. Usually when you read a book you learn about how the stuff works and then you learn the application. In this book, however, the authors walk you through developing a website, and then they dive into how the components really work.

I would also recommend you get the ebook if you want to get the most of the book, sadly that seems to cost extra (about $12).

I've played with web development in PHP, and though I enjoy it, the time required to develop the structure and functionality of a website takes a while. After hearing a presentation on Ruby on Rails, I decided that I would check it out. After perusing many websites, I found it to be very quick in developing the structure, but I had minor trouble with the functionality, mainly because of my unfamiliarity with Ruby.

After acquiring experience with Ruby, this book is a great way to understand the Rails methodology. Don't expect it to teach you Ruby, though; the main focus of the book is the Rails framework and the Agile development process. Be ready to invest in a good Ruby reference along with purchasing this.

Grab this book and grab Programming Ruby 2nd Edition. I recommend the 2nd Edition Beta of this text though (available at the Pragmatic Programmers site) because it is more up to date. These books are great if you know how to program and need to get going quick with Ruby and Rails!

If you want to learn RubyonRails, you need to buy this book. Even if you have never programmed in Ruby before, this book will help you get started in Rails development and give you a general introduction to the power of coding in Ruby.

Most books will just give random code samples and small, disconnected tutorials. This book will walk you through the development process and guide you through creating a Rails app from start to finish.

Must read for any Rails developer.

While the book takes a sometimes overly casual tone (depending on your taste), it serves as an excellent introduction to Rails (as well as to the Ruby programming language). Indeed, it follows the programmer's maxim of learning by example; each chapter focuses on the continuing development of an actual web application.

OK, I'm coming to rails late. I've played with Ruby on and off for about a year. I though it was a bit of a "kitchen sink" language until I got a good kick in the head by Neil Ford.

So this week I picked up this book (version 2) and I started reading it. It is, as far as technical books go, a page turner.

It gives a basic overview and the walks through an example as a tutorial.

I recommend you learn a little Ruby first (not necessary but makes working through the examples more focused on Rails rather than Ruby and Rails).

If you want to learn about Ruby on Rails and get an idea of what web development should be, read this book. THEN, the next time you need to start working on a site for a customer, sit down with them and start developing the site in real-time.

If they don't like Ruby, call it an "executable requirements description". Eventually, they might even think that the solution is good as is. If not, you still have a better explanation of where to go.

After Rails, I'm going back to RSpec and story tests and examine the maturity of developing a Ruby solution using TDD. I'm pretty sure it's already being done, so I just need to get on that learning curve.

This is a GREAT book. Get it, read it, TYPE in the examples - ok maybe download the CSS's and the style-sheet.

WARNING: the material related to OS X installation is a bit out of date. Use macports and install mysql, rb-mysql, rails, ruby (and I'm probably forgetting something), change your path to point to where that stuff got installed (probably /opt/local/bin/) and you'll be good to go - once you get mysql setup. There are some chicken scratchings here: http://schuchert.wikispaces.com/Ruby.RailsConfiguration.OSX, or do a google search. It'll be October 2008 before I actually put up good details, but it'll happen.

Not only is there a great framework to this textbook will introduce you to, but this is written in the perfect balance of interesting style and serious technical content along with compelling example that I've ever seen in any book. I give this book my very highest recommendation and I give the rails framework five stars as well for being an excellent easy to use and very functional framework.

This book seems to cover everything that I'm interested in and is able to adapt to different levels of knowledge that I'm able to arrive at in programming in Ruby language. The book does not insult the reader and while it challenges the reader doesn't over challenge or overwhelm any point. I can only recommend it for my particular demographic of rails newbies, but I think this book will work very well for anyone else who might be more familiar with Ruby and the rails framework.

I wanted to learn something about RoR and this book is perfect!
Easy to read, easy to understand, with a lot of examples, perfect for beginners & for advanced users because in the middle explain a lot of interesting things!
i recommend to buy it

Great book to start off with. Has a good tutorial on building a shopping cart application. Then one can learn from that to develop a application that is unique for their business.

When I came onto a new project, I needed to learn Rails fast. This book got me up and running in no time. Despite being new to Ruby, I found the examples easy to follow and the sample application easy to work with. This book is the gold standard when it comes to Rails.

I thought the book was well written , concise with plenty of examples--especially the part about the css style sheets. I myself will recommend this book to any one who is interested in web development as I have currently used much of their work in my client sites such as:

[...]

Take a look of what I have implemented as it pertains to the book