Customer Reviews

Rails for Java Developers

5 star:		(9)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(2)

 

 

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.

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.

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".

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.

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.

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 started this book awhile ago, but then got distracted with various things and left it. I recently started reading it again and just finished it.
I have been puzzled by the relatively lower ranking of this book in the Amazon sales rankings compared to other Ruby/Ruby on Rails books. What is even more puzzling is the fact that amlost everyone who has bothered to write a review has given it full five starts including myself. Here is my guess on why is it so (I may be wrong):
This book assumes certain experience, skill set, knowledge, and sophistication on the reader's part. This means that the person should have a good deal of Java and more importantly J2EE knowledge and real-world experience both as a developer and architect. Unless one has suffered through the baggage that goes with "Enterprise Java", it is very hard to understand and appreciate what the authors are trying to say. Merely having played with J2EE/Java is not sufficient to enjoy this book and get something out of it. You have to lived through at least one complete life-cycle of a typical J2EE project to appreciate the fine points that the authors are making in this book.
One thing is clear to me: even though they try very hard to maintain a neutral posture throughout the book, given a choice, they would rather code Ruby and RoR than Java and J2EE (who wouldn't?).
If you have the necessary experience, knowledge, and skills; then the book becomes very useful. I have particularly enjoyed the later chapters of the book dealing with Testing, Rake, Web Services, and Security.
I hope that they continue to "push" the boundaries of Ruby on Rails knowledge and share it with the rest of us in their excellent writing style.

[...]Here is the brief summary of strengths and weaknesses of Rails for Java Developers.

Strengths:
* The book gives excellent overview of Ruby and Rails concepts.
* This book is specifically written for experienced Java developers who want to learn Ruby and Rails. To ease the transition, the authors illustrate all the concepts addressed in the book with Java examples. Ruby concepts are contrasted with similar Java concepts. Rails notions are illustrated with Struts examples.
* The book covers all the aspects of multi-tier enterprise system development (persistence, business logic, presentation features, MVC implementation, security, testing, etc.). It also covers a variety of agile practices such as test-driven development and continuous integration describing Java and Rails approaches to those practices.
* The book drives home the point of Ruby's and Rails' simplicity (represented by the motto "convention over configuration") comparing it with configuration-heavy Java approach.
* The book does an excellent job highlighting the differences between the two ecosystems (dynamic vs. static typing, using single language for all tasks (Ruby) vs. using multiple languages (Java, XML), simplicity vs. power, etc.). It identifies the situations where either of the solutions would be more appropriate.
* Besides being informative, the style is entertaining and lighthearted.

Weaknesses:
* You may have difficulty following some of the books examples, if you are new to Ruby. Although it starts with a chapter on Ruby basics, the book is not intended as Ruby tutorial.
* The book has relatively few hands-on exercises. Its main goal is to introduce Ruby and Rails concepts. It does it by examining a variety of Ruby, Rails and Java samples. This approach might be somewhat deficient for people who learn better by doing rather than by looking at the code.

This book would have been excellent in its day, but it is seriously outdated. None of the examples work anymore with current versions of ruby and/or rails.

Please note that this book is about Rails 1.x series. I tried following the examples with Rails 2.3, but they just don't work because there are so many differences between the old 1.x and the current 2.x/3.x versions.