Buy Used
CDN$ 0.01
+ CDN$ 6.49 shipping
Used: Like New | Details
Condition: Used: Like New
Comment: Ships from the USA. Please allow 14-21 business days for delivery. This copy appears to be in nearly new condition. Free State Books. Never settle for less.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Rails for Java Developers Paperback – Feb 23 2007

See all formats and editions Hide other formats and editions
Amazon Price
New from Used from
"Please retry"
CDN$ 66.81 CDN$ 0.01

Harry Potter and the Cursed Child
click to open popover

No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
Getting the download link through email is temporarily not available. Please check back later.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Product Details

  • Paperback: 304 pages
  • Publisher: Pragmatic Bookshelf; 1 edition (Feb. 23 2007)
  • Language: English
  • ISBN-10: 097761669X
  • ISBN-13: 978-0977616695
  • Product Dimensions: 19.3 x 2.5 x 22.8 cm
  • Shipping Weight: 635 g
  • Average Customer Review: Be the first to review this item
  • Amazon Bestsellers Rank: #2,253,048 in Books (See Top 100 in Books)
  •  Would you like to update product info, give feedback on images, or tell us about a lower price?

Product Description

About the Author

Stuart Halloway is a member of Clojure/core and CTO at Relevance, where he spends his time on secret projects for world domination, and watching Phineas and Ferb.

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) HASH(0xa2304ba0) out of 5 stars 15 reviews
8 of 8 people found the following review helpful
HASH(0x9c04d66c) out of 5 stars Necessary for Today's Java Developer Feb. 21 2007
By David Bock - Published on
Format: Paperback
I had the privilege of seeing this book pre-release (being the Prsident of the Northern Virginia Java Users Group has its privileges...), and I must say, it contains material necessary for today's Java Programmer.

Love it or hate it, Rails is a platform that is geting a lot of atention these days, and a competent softare engineer cannot afford to *not* have an opinion on it... The evolution of Java is being heavily influenced by ideas from this community. And why not? Good ideas ae good ideas, no matter where they come from. Clearly, Rails contains concepts that can be 'borrowed' and brought over into Java with great success - one just has to look at the landscape of recent open source projects to see this in action (and of course, a lot of these ideas were borrowed from the Java community in the first place).

So, if you are a developer who has cut his teeth for years on Java, what is the shortest path to get up to speed with Rails? I have to recommend this book. It explains both Ruby and Rails by comparing and contrasting to things you are already familiar with from your Java experience. The authors are also exceptional presenters and writers - the book is written well and the ideas are clearly refined from battle-testing as presentation and classroom materials.
6 of 6 people found the following review helpful
HASH(0x9c04d6c0) out of 5 stars For all Java web application developers Feb. 21 2007
By Amazon Customer - Published on
Format: Paperback
R4JD is an important book to read for Java web application developers, whether or not they are planning a move to Rails. The structure of the book is unique in that it explains concepts in Ruby, Rails, and Rake by comparing them to the equivalent functions in Java, Hibernate, Struts, JSP, JUnit, and ant. It is wonderful at helping the developer quickly learn how to do all of the things he or she already knows how to do into the Rails world. Even for the developer who is not considering using Rails at the moment, it provides a quick and useful framework for understanding the differences of the Rails way and anticipate how the Java technology stack will be responding to new ideas about the way web application development can be done. Simply understanding the structure of an end to end Rails application provides a good template for how to build a Java web application with the suite of tools used for comparison.

Specifically, the authors' coverage of the Ruby language is quite good in terms of being very clear and leading the reader from an understanding of how to write Java-style to Ruby to a deeper level of being able to write more idiomatic Ruby code. The coverage of ActiveRecord and Hibernate is quite informative, although it doesn't get into any of the approaches to caching data in Rails, it is a good introduction to the differences (Rails tends to cache views). The section on Controllers using Struts is enough to make me wish I never see another routing configuration xml file again.

One of the primary differences between Java web applications and Rails web applications is that the Java web apps tend to use a lot of configuration files written in XML. While type safety is often listed as something people like about statically typed Java, the book should point out that all of this XML plumbing is not quite type safe either. The magic of Ruby's dynamic nature and more complete object oriented features such as duck typing and mixins help provide an escape for this, where the story is really all in the code.

All in all, this is a very readable technical book. It's a quite a bit more than a reference manual and is filled with generous nuggets of wisdom that have already made me a better developer.
4 of 4 people found the following review helpful
HASH(0x9c04daf8) out of 5 stars Gentle Introduction to Ruby on Rails for the Experienced Java Developer May 19 2007
By Jason - Published on
Format: Paperback
In "Rails for Java Developers", Stuart Halloway and Justin Gehtland provide an introduction to Ruby and the Rails web application framework aimed at the Java developer more familiar with frameworks such as Struts and Hibernate. There's a lot of buzz in the Java community surrounding Ruby and Ruby on Rails so this title is quite timely.

Halloway and Gehtland provide a tutorial to learning Ruby and Rails by examining similarities with Java. The tutorial progresses by providing examples in both Ruby and Java using popular Java frameworks. The introduction of Ruby and Rails concepts by juxtaposing them with similar concepts implemented in Java is comforting for the developer who may feel a little intimidated by the differences between the languages. Working through the book, the Java developer will learn the basics about creating and deploying Ruby on Rails applications, picking up an exciting new language along the way.

The first three chapters introduce the Ruby programming language. This is the best Java-centric Ruby introduction that I've seen and it's something I wish I had available to me when I was first learning the language. The rest of the material covers the basics of Rails applications as well as web services and security issues. I found the chapters on testing and automating the development process to be particularly good.

The approach this book takes may not be suitable for everyone. After a certain point, I found that the constant juxtaposition of the Java way of accomplishing a task with the Ruby on Rails way of accomplishing a task wore a bit thin. I found myself just trying to skip past the Java bits to get on with the Ruby. Still, I found the book to be quite good overall. If you are an experienced Java developer seeking a gentle introduction to Ruby on Rails, you can't do better than "Rails for Java Developers".
3 of 3 people found the following review helpful
HASH(0x9c04deb8) out of 5 stars If you know Java and are curious about Rails, buy this book. April 12 2007
By James A. Van Fleet - Published on
Format: Paperback
Simply put, I wish that I had been able to read Stu Halloway and Justin Gehtland's Rails For Java Developers before I began on my own journey of learning Ruby and Rails after a professional life of Java development. If you are looking for a book that cuts through the hype to a commendably unbiased comparison of the web development environment in these two great languages, look no further.

With "Rails is not for everything" on the first page of the preface, the book identifies its audience as informed Java developers who haven't necessarily made up their minds about Ruby and Rails. To paraphrase the authors, however, Java programmers have lived through a lot of the struggles that Rails attempts to address. Through showing how and explaining why this is the case, this book serves as an excellent guide for those of us willing to investigate a new technology for web development.

When you buy a new car, the first step is the test drive. In the same way, Chapter 1 is like a test-drive of a "car" unlike any you've ever been in as a Java developer. The tour is as brief as possible while still exposing the reader to all of the ideas that the rest of the book fleshes out. In fact, for those who found any particular topic instantly appealing, the book provides an instant reference for where to turn next.

After any test drive invigorating enough to get you to purchase the vehicle, the dealer will often sit you in the drivers seat and point out where everything is in the unfamiliar cockpit. Chapter 2 is much the same, showing how familiar concepts in the Java language are expressed in the Ruby language. The chapter contains ten sections on topics ranging from the basics of primitive types and arrays to control flow and exception handling. This sets the stage for Chapter 3 where the authors explore those aspects of Ruby that either have no clear analogue in Java or are essentially unrecognizable.

In Chapter 4, the authors crack the hood and show you just how different Hibernate and ActiveRecord are from a developer's perspective. There are a lot of differences, and I feel this chapter will be the first that begins to give the reader an idea about whether they'll enjoy the Rails framework as a whole. The "Rails Way" begins to become visible and stands in stark contract to the choices that Hibernate makes in its own implementation. The authors' aim is to compare these two frameworks without bias, and they succeed.

A comparison of Struts and ActionController is the focus of Chapter 5. Struts' status as the lowest-common-denominator of the Java frameworks that specialize in communication with web forms led to its inclusion in this chapter. Again the authors walk through a simple example, illustrating the differences in approach. Many of Rails' optimizations towards developer simplicity come at a cost of application performance. An investigation at the end of this chapter provides an estimation of the ultimate cost of those tradeoffs.

Chapter 6 focuses on rendering HTML, where the Java developer space is somewhat more fragmented. As a result, a lot of the Java material focuses on general concepts, while the Rails material is focused on some of the most advantageous elements of the Rails stack-- specifically AJAX and RJS. I do find it to be a bit strange that the authors took the time to discuss Markaby, which, to my knowledge, is not very widely used at all.

Testing is the focus of Chapter 7. Although treatment of rcov and the "dummy objects" make this a useful section even for intermediate Rubyists, I'm a bit surprised that the authors did not focus more specifically on Rails testing. One of the central tensions in the book (and between outspoken practitioners of both languages) is the attitudes that the respective communities have towards choice. Perhaps more than in any other area, the submission to "opinionated software" reaps considerable rewards when testing Rails code.

Chapter 8 deals with the development process itself, focusing on build tools like Rake and Ant, and continuous integration tools like Cerebus and CruiseControl. The authors do not spend as much time on the inner workings of those libraries as they do on the Rails libraries. That's understandable, because uses of a build tool are myriad; this book is meant to be an introduction. If build tools and deployment are areas of interest for you, you'll likely need other resources to become more familiar with the breadth of offerings on both the Java and Ruby sides. My experience tells me that Rake is more expressive than Ant, but there's certainly a learning curve for both.

Chapter 9 concerns Web Services and XML. There are many ideas discussed in this short chapter, because this topic is getting attention in different ways among leading Ruby and Java programmers. There is a lot of enthusiasm for REST on the part of many Rails developers, and so the authors provide a brief overview of what REST is, and how Rails supports it. Java developers have to parse XML in many different contexts, and there's a lot of work that has gone into developing a useful and highly efficient stack for processing XML data. As a result, comparisons and contrasts dominate the chapter.

Chapter 10 deals with security and doesn't include too much treatment on the Java side. It seems to be a defense of Rails against some common attacks. While I do feel that's useful information, especially for any reader in a discussion with his manager, it seems that Ruby security libraries are not yet as mainstream as those of Java, such as Acegi.

If you've read this far, you should definitely buy the book.
3 of 3 people found the following review helpful
HASH(0x9c04df9c) out of 5 stars Attention Java Developers - A Must Read Book! Feb. 24 2007
By W. Mark Richards - Published on
Format: Paperback
Stu and Justin hit a sweet spot with this rails book. Unlike other Ruby and Rails books, this one specifically focuses on learning Rails, Ruby, Rake, and ActiveRecord from a Java Developer's standpoint. In my opinion there is no better way to learn Rails than the methods and techniques used in this book. Stu and Justin use practical techniques and examples thoughout the book that you can easily use to code along side the book while reading it.

The other thing I like about this book is that they cover the complete picture, not just Rails. There are chapters devoted to Ruby, ActiveRecord, Rake, security and testing - all from a Java Developer's point of view. Through this book Stu and Justin correctly point out that it doesn't have to be an either-or situation. This is not a "one-size-fits-all" world. They are right - and that is the main reason you should read this book. Read this book to expand your knowledge, grow in your career, and learn not only how to code in Rails but how to be a better Java Developer as a result.