Rails for Java Developers

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

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.

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.

I'm a long-time Java developer who has been working with Rails a lot recently. A lot of the people I know who are doing Rails fit that same description. Rails is fun, and a very pleasant breath of fresh air compared to all the Java-based web frameworks I've used. But I don't hate Java -- far from it. It just turns out that, like any other language or platform, Java isn't the right choice for every task. Ruby and Rails are much better choices for many kinds of web applications. Learning Rails doesn't have to mean that you're turning your back on the language that's put food on your table for the past few years. Every developer should have more than one tool in the toolbox, and if you're a Java programmer doing web development, Rails is a tool you should explore. In "Rails for Java Developers", Stuart Halloway and Justin Gehtland have that same attitude, and that makes for a fantastic book. They also come from strong Java backgrounds, and they bring that perspective to the book. They explain Ruby and Rails in ways that build on your knowledge of Java. They answer the questions that Java developers will ask ("what about connection pools?" and "why no taglibs?"). And most refreshingly of all, they're honest about situations where Java might be a better choice. Every Java developer needs to understand Rails, but only some of us will switch and become full-time Rails developers. The others will learn useful lessons they can apply in their Java development, or becom bilingual developers who use Ruby and Rails for situations where they make sense. In any case, this is the book to start with.

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.