The Spring Roo available today is the result of relatively recent engineering, but the inspiration for the project can be found several years earlier.
The historical motivation for "ROO" can be traced back to 2005. At that time the project's founder, Ben Alex, was working on several enterprise applications and had noticed he was repeating the same steps time and time again. Back in 2005 it was common to use a traditional layering involving DAOs, services layer and web tier. A good deal of attention was also focused around that time on avoiding anaemic domain objects and instead pursuing Domain Driven Design principles.
Pursuing a rich domain model led to domain objects that reflected proper object oriented principles, such as careful application of encapsulation, immutability and properly defining the role of domain objects within the enterprise application layering. Rich behaviour was added to these entities via AspectJ and Spring Framework's recently-created @Configurable annotation (which enabled dependency injection on entities irrespective of how the entities were instantiated). Naturally the web frameworks of the era didn't work well with these rich domain objects (due to the lack of accessors, mutators and no-argument constructors), and as such data transfer objects (DTOs) were created. The mapping between DTOs and domain objects was approached with assembly technologies like Dozer. To make all of this work nicely together, a code generator called Real Object Oriented - or "ROO" - was created. The Real Object Oriented name reflected the rich domain object principles that underpinned the productivity tool.
ROO was presented to audiences at the SpringOne Americas 2006 and TSSJS Europe 2007 conferences, plus the Stockholm Spring User Group and Enterprise Java Association of Australia. The audiences were enthusiastic about the highly productive solution, with remarks like "it is the really neatest and newest stuff I've seen in this conference" and "if ROO ever becomes an open source project, I'm guessing it will be very polished and well-received". Nonetheless, other priorities (like the existing Spring Security project) prevented the code from becoming release-ready. More than twelve months later Ben was still regularly being asked by people, "whatever happened to the ROO framework?" and as such he set out about resuming the project around August 2008.
By October 2008 a large amount of research and development had been undertaken on the new-and-improved ROO. The original productivity ideas within ROO had been augmented with considerable feedback from real-life use of ROO and the earlier conferences. In particular a number of projects in Australia had used the unreleased ROO technology and these projects provided a great deal of especially useful feedback. It was recognised from this feedback that the original ROO model suffered from two main problems. First, it did not provide a highly usable interface and as such developers required a reasonable amount of training to fully make use of Roo. Second, it imposed a high level of architectural purity on all applications - such as the forced use of DTOs - and many people simply didn't want such purity. While there were valid engineering reasons to pursue such an architecture, it was the productivity that motivated people to use ROO and they found the added burden of issues like DTO mapping cancelled out some of the gains that ROO provided. A mission statement was drafted that concisely reflected the vision of the project, and this was used to guide the technical design.
In early December 2008 Ben took a completely rewritten ROO with him to SpringOne Americas 2008 and showed it to a number of SpringSource colleagues and community members. The response was overwhelming. Not only had the earlier feedback been addressed, but many new ideas had been incorporated into the Java-only framework. Furthermore, recent improvements to AspectJ and Spring had made the entire solution far more effective and efficient than the earlier ROO model (such as annotation-based component scanning, considerable enhancements to AJDT etc).
Feedback following the December 2008 demonstrations led to considerable focus on bringing the ROO technology to the open source community. The name "ROO" was preserved as a temporary codename, given that we planned to select a final name closer to official release. The "ROO" project was then publicly presented on 27 April 2009 during Rod Johnson's SpringOne Europe keynote, "The Future of Java Innovation". As part of the keynote the ROO system was used to build a voting application that would allow the community to select a final name for the new project. The "ROO" name was left as an option, although the case was changed to "Roo" to reflect the fact it no longer represented any acronym. The resulting votes were Spring Roo (467), Spring Boost (180), Spring Spark (179), Spring HyperDrive (64) and Spring Dart (62). As such "Spring Roo" became the official, community-selected name for the project.
Roo 1.0.0.A1 was released during the SpringOne Europe 2009 conference, along with initial tooling for SpringSource Tool Suite. The Roo talk at the SpringOne Europe 2009 conference was the most highly attended session and there was enormous enthusiasm for the solution. Roo 1.0.0.A2 was published a few weeks later, followed by several milestones. By SpringOne/2GX North America in October 2009, Roo 1.0.0 had reached Release Candidate 2 stage, and again the Roo session was the most highly attended session of the entire conference. SpringSource also started hosting the highly popular Spring Discovery Days and showing people around the world what they could do with the exciting new Roo tool. Coupled with Twitter, by this stage many members of the Java community had caught a glimpse of Roo and it was starting to appear in a large number of conferences, user group meetings and development projects - all before it had even reached 1.0.0 General Availability!
Spring Roo's mission is to "fundamentally and sustainably improve Java developer productivity without compromising engineering integrity or flexibility".
Here's exactly what we mean by this:
"fundamentally": We believe a fundamental improvement in developer productivity is attainable. Tools, methodologies and frameworks that offer incidental improvement are nowhere near enough.
"and sustainably improve": A one-off improvement in productivity isn't enough. The productivity improvement needs to sustain beyond the initial jump-start, and continue unabated over a multi-year period. Productivity must remain high even in the face of radically changing requirements, evolving project team membership, and new platform versions
"Java developer productivity": Our focus is unashamedly on developers who work with the most popular programming language in the world, Java. We don't expect Java developers to learn new programming languages and frameworks simply to enjoy a productivity gain. We want to harness their existing Java knowledge, skills and experience, rather than expect them to unlearn what they already know. The conceptual weight must be attainable and reasonable. We always favour evolution over revolution, and provide a solution that is as fun, flexible and intuitive as possible.
"without compromising": Other tools, methodologies and frameworks claim to create solutions that provide these benefits. However, they impose a serious cost in critical areas. We refuse to make this compromise.
"engineering integrity": We embrace OO and language features the way Java language designers intended, greatly simplifying understanding, refactoring, testing and debugging. We don't force projects with significant performance requirements to choose between developer productivity or deployment cost. We move processing to Generation IV web clients where possible, embrace database capabilities, and offer an optimal approach to runtime considerations.
"or flexibility": Projects are similar, but not identical. Developers need the flexibility to use a different technology, pattern or framework when required. While we don't lock developers into particular approaches, we certainly provide an optimal experience when following our recommendations. We ensure that our technology is interface agnostic, gracefully supporting both mainstream IDEs plus the command line. Of course, we support any reasonable deployment scenario, and particularly the emerging class of Generation IV web clients.
We believe that Spring Roo today represents a successful embodiment of this mission statement. While we still have work to do in identified feature areas such as Generation IV web clients, these are easily-achieved future directions upon the existing Roo foundation.