Jspresso 3.5.0

You will find below some of the key features of the Jspresso framework. Although the list might not be exhaustive, it should give you a good idea of how extensive the coverage of Jspresso is.
General design

* Develop by assembling built-in java beans descriptors through dependency injection. Descriptors can also be dynamically composed in plain java code if needed.
* Desktop ergonomics oriented. Jspresso is not another web framework so just forget about page flows.
* I18N and security (authentication and authorizations) as first citizens.

Domain model

* Rich domain model paradigm (as opposed to thin or even anorexic domain models). Entities are responsible of their integrity, offer services and handle their relationships to others.
* Model descriptors allow for the implementation of arbitrarily complex domain models :
o 1-N, N-1, N-N, 1-1 unidirectional and bidirectional relationships
o association and composition semantics
o list and set collection semantics
o entities, inlined components and service interfaces
o entities inheritance
o more than 15 property types handled through all layers (string, integer, enumeration, date, duration, color, percentage, binary, ...)
* Services offered by entities (and components) are objects themselves that are assembled in the entity (or component) through dependency injection. This allows for easy mock-up, logging and tracing, KPI implementation, inheritance between services, ... You can get all the advantages of AOP without its drawbacks.
* Model descriptors offer fine-grained model description (rich validation constraints on properties). This is one of the most important feature of Jspresso since this rich semantic is then leveraged in all other layers without the need of repeating things. For instance, once you have constrained a property with a regular expression, views presenting this property will automagically enforce this constraint by allowing only matching values to be entered. Describe finely your domain model and building a complete application over it will be an effortless process.
* Jspresso entities (and components) support computed properties. Once defined, they are just usable as any primary property in the other layers.
* Jspresso entities (and components) support life-cycle interceptors (on-create, on-persist, on-update, on-delete and on-load). Life-cycle interceptors are objects that are assembled in entities and dynamically triggered by the framework when needed.
* Jspresso entities (and components) support property modifiers interceptors (before, intercept, after). Property modifiers interceptors are objects that are assembled in entities and dynamically triggered by the framework when needed.
* Jspresso handles transparently the persistence of the domain model in the backend store. Everything needed to achieve this is inferred form the model description. Atomic backend synchronization is also completely handled by the framework and allows delayed updates of in-memory changes.

Views

* Technology neutral view description. Following the assembling principle, views are generated at runtime through built-in factories depending on the chosen deployment strategy. Developing views is achieved by composing technology agnostic java beans view descriptors; this means absolutely no Swing, Flex, ULC, javascript, HTML or whatever specific GUI coding. Jspresso offers an extensive range of ready-to-use, highly configurable, view descriptors including :
o tree view
o table view
o list view
o form (component) view leveraging all supported property types with calendar component, filtered fields, list of values for relationships, ...
o single property view
o image view
o composite (container) views :
+ border (north, south, east, west, center) composite view
+ card composite view
+ split composite view
+ tab composite view
+ grid composite views : evenly distributed size grids and constrained distributed size grids
* Jspresso is open for extensions. You can easily implement your own view descriptors and extend the built-in view factories so that they are ready to handle them.
* View descriptors are highly configurable but offer sensible default values; you can assemble rich views in minutes. General customizations include fonts, colors and border. Of course, each view descriptor allows for specialized customization; some examples of such customizations are :
o number of columns and list of displayed properties in form views
o split orientation in split views
o columns in table views
o many, many others...
* Jspresso views are natively internationalized. Special care has been taken to nicely handle common I18N problems such as translation lengths differences by exclusively using layouts behind the scene; this means no absolute positioning of components and thus GUI resize friendly behaviour.
* Jspresso avoids description repetition. Views are automatically configured based on their underlying model. For instance, fields (or table columns) preferred length are computed based on the maximum length constraint of the underlying model property.

High-level application components

* Jspresso offers a rich set of ready-to-use high level application components that are ready to be assembled in application modules. For instance, Jspresso offers a highly configurable built-in module for CRUD operations on an entity family.

Binding

* Jspresso transparently implements a true bidirectional MVC (Model-View-Controller). Views are always in sync with their session, in-memory, server-side model. This kind of design is a real challenge for distributed applications since it implies a lot of effort in terms of client-server communication efficiency and model integrity (Jspresso heavily uses the Unit-of-Work architectural pattern to guarantee the coherence of the backend transactional updates and of the in-memory model state).
* Binding views and model doesn't require any special effort from the developer. It is just implicit when you describe your views. Binding is based on the JavaBeans' property semantics (property accessors).

Actions

* Jspresso offers a rich and extensible set of built-in actions. Actions are implemented following a comprehensive action framework. There are more than 50 different built-in actions ready to be customized and assembled ian Jspresso applications. Some example of such actions are :
o save action that transactionally updates the backend store
o copy, cut, paste actions that manage an entity oriented clipboard
o create and add, remove from, duplicate and add actions to handle "master-detail" like GUIs
o query action that implements "query by example" to retrieve entities from the backend store
o wizard action that chain views and populate an arbitrary context
o many, many others...
* Jspresso actions are naturally split in 2 main categories :
o front-end actions that handle user interactions with the application. They offer customizable (and internationalized) tool tips, icons, keyboard shortcuts, ...
o back-end actions that are faceless and thus GUI independent. They are related to domain model operations.
* Front-end actions are assembled in views so that users can trigger them. They are composed in a tool bar attached to the view but can also be triggered using a contextual pop-up menu.
* Jspresso actions can be chained together so that you can implement complex application workflows by composing basic actions.
* Jspresso actions are objects. This means that you can easily implement object-oriented hierarchies of actions, capitalize standard action sets that are reusable across your company applications, implement common behaviour for tracing, performance monitoring of services and so on.

Security

* Security is everywhere in Jspresso but you won't notice it unless you actually need it.
* Authentication is based on JAAS. Jspresso provides standard login modules that are fully JAAS compliant.
* Authorizations are not handled by JAAS. This choice is deliberate since we believe that JAAS authorizations (and all the authorization frameworks we heard about) are too much code related, quite difficult to implement and lack some higher level concepts (like "make this field read-only for non-admin profiles"). So we implemented a simple yet complete and powerful authorization infrastructure :
o based on roles that are hierarchically organized and populated by JAAS authentication
o declarative so that you just have to configure the descriptors with a list of authorized roles (using their names). Whenever this list is missing means that there is no restriction on the underlying component.
o applicable in all layers (model, view, actions).
* Each and every part of a Jspresso application is securable with authorization rules. Authorizations are propagated across layers so that if you declare a restriction in the domain model layer it is automatically propagated in the related views. But of course you can declare the restriction in the view (or part of the view) itself. Securable Jspresso components include :
o entity (or component) families
o single entity (or component) properties
o actions
o views (and view parts)

I18N

* Jspresso has been developed to address the widest range of business. That is why it has been built with I18N in mind since the very beginning. But again, Jspresso makes internationalization easy.
* I18N is not tied to the client desktop locale but to the user preferred language.
* I18N applies to label translation and various formats (date, decimal, ...)
* I18N traverses all layers with easy-to-apply conventions. For instance, whenever a form field is presented to the user, the framework will automatically look for a translation of the underlying property name. This means that once you've translated your entities and properties names, all your application is potentially internationalized. You can of course override this standard behaviour if you need to translate the same property differently in different views.

Deployment architecture

* Seamless multi-channel deployment of the front-end :
o Flex (Flash)
o Qooxdoo (Ajax)
o Swing
o ULC (lightweight distributed swing, commercial development licence needed)
o WingS (Ajax)
* No need for a full-fledged application server unless you really need it. Jspresso embraced the Spring framework philosophy to keep the required software infrastructure as light as possible. The minimum requirement is a 2.5 servlet container (even not needed for a 2-tier swing deployment) and an Hibernate supported database.




Key benefits

* The whole development team shares common high-level concepts and vocabulary. You can even share them with your business consultants. This makes specifications, design and communication easier and much more efficient.
* It's a matter of hours to have something up and running. But what you get is not a quick and dirty prototype you will throw away when the project evolves. It already contains all the robust foundations of a well designed, loosely coupled application.
* Don't think in months to get your final deliverables. Since the development team focuses on the business, you can deliver a mid-size, robust, performant and maintainable application in a few days.
* The assembling strategy and the use of dependency injection as the core glue is perfectly suited to large team development. Each and every single part of the application can easily be mocked-up so that different concerns can implemented in parallel.
* You will be confident in the delivery avoiding the "dark tunnel effect". Using a prescriptive framework helps you at all stages of the project :
o sizing : you won't play the russian roulette anymore since you can precisely split the specifications in terms of Jspresso components.
o development : you won't need extra-specialized people in your team anymore. Jspresso strongly structures the application building blocks and how they interact between each other. Each piece of code is nicely de-coupled from the others so that if something messy is coded, it is always easily identified, isolated and fixed.
o documentation : a Jspresso powered application is entirely made of the assembly of built-in java beans descriptors. This gives you the oportunity to leverage this java bean meta-model for all sorts of automated processing including technical documentation of all application layers.
o maintenance : since the structure of a Jspresso application always follow the same architecture, anyone who is aware of it can instantly understand the resulting software. No more "We have to call Vince because nobody understands what he has coded".
* You can very easily leverage your business knowledge and capitalise reusable components (business objects, business rules, actions, views...) that are ready to be assembled in new applications speeding up again the development process.
* You protect your investments against software evolution. The resulting applications are completely de-coupled from the underlying technical building blocks. We make a strong emphasis on ascendant compatibility and it is the role of the framework to bring a coherent technical stack for new releases "drop and replace".
* Jspresso is production ready and doesn't require neither a full-stack J2EE application server and nor a high cost database server (although some projects may need one of them for specific needs). There has been Jspresso powered applications in production for 2 years now on the Apache / Tomcat / MySQL stack.
* Jspresso is free so it makes your software potentially license cost-free.