Stripes is a presentation framework for building web applications using the latest Java technologies. The main driver behind Stripes is that web application development in Java is just too much work! It seems like every existing framework requires gobs of configuration. Struts is pretty feature-light and has some serious architectural issues (see Stripes vs. Struts for details). Others, like WebWork 2 and Spring-MVC are much better, but still require a lot of configuration, and seem to require you to learn a whole new language just to get started.

Goals of Stripes

• Make developing web applications in Java easy
• Provide simple yet powerful solutions to common problems
• Make the Stripes ramp up time for a new developer less than 30 minutes
• Make it really easy to extend Stripes, without making you configure every last thing

Key Features

     - Zero external configuration per page/action (ActionBeans are auto-discovered, and configured using annotations)
     - Powerful binding engine that will build complex object webs out of the request parameters
     - Easy to use (and localized) validation and type conversion system
     - Localization system that works even when you use direct JSP->JSP links
     - Ability to re-use ActionBeans as view helpers
     - Ridiculously easy to use indexed property support
     - Built in support for multiple events per form
     - Transparent file upload capabilities
     - Support for incremental development (e.g. you can build and test your JSP before even thinking about your ActionBean)
     - And a lot of built in flexibility that you only have to be aware of when you need to use it
    
Stripes was initially conceived and developed as a lightweight framework, taking advantage of the latest technologies to remove the drudgery from Java web development. The following set of principles describe the general philosophy in developing Stripes, and should inform all future development:

Simplicity

Simplicity can mean many things, but particularly this means keeping Stripes easy for developers to pick up, to learn and to use on a daily basis. In this sense, simplicity means intuitiveness and productivity. Concretely, this means things like:

• Not having to link lots of artifacts together to get things done (keeping a bean and a view in sync is enough!)
• Not introducing extra dependencies (jars) unless they provide amazing value
• Not introducing additional languages (EL, scripting or configuration) for users to learn
• Relying on convention as much as possible, but making it easy to override
• Generalizing far enough to cover all common cases, but not so far as to be confusing or meaningless

Web-i-ness

Stripes, at its core, is an action framework and action frameworks as a whole don't shy away from the fact that the entire web is implemented on top of a stateless protocol (HTTP). There are myriad shortcomings in HTTP, and in the various dialects of HTML that are in use. Trying to hide the fact that HTTP is stateless and provide a framework that hides this fact from the developer is fraught with issues, and nearly always leads to a leaky abstraction. Component frameworks tend to lead to more complicated programming environments, while simultaneously not dealing completely with state issues.