Jspresso is a full-stack, open-source framework, written in Java which is dedicated at creating single page corporate applications.

 

By full-stack, we mean Jspresso is taking care of :

  1. the (arbitrarily complex) domain model, along with its persistence and business rules
  2. the set of services that are offered to the user or made available through external interfaces
  3. the UI that is deployed to the end user in the browser

In order to bring everything smoothly to the developer, Jspresso comes with a Groovy DSL that is called Sugar For Jspresso (aka SJS).

 

Jspresso also comes with an Eclipse plug-in, Jspresso Developer Studio (aka JDS) that brings navigation, auto-completion, code generation and a lot of other useful features to SJS.

What makes Jspresso different ?

First of all, its approach to application developement is singular. Although it embraces well-proven design patterns, the way you code your application is more about assembling building blocks than actually writing them (with the obvious exception of the business rules / services). That is what we call a prescriptive framework since the design of the final software is built-in. This makes the code extremely fast to write, well organized and more robust since all the orchestration is handled by the Jspresso runtime.

Want to see some code ?

To demonstrate how consise but expressive the Jspresso code can be, let’s take an example :

Entity('City',
        icon:'city-48x48.png',
        pageSize:50,
        toString:'name') {

  string_64 'name',
             mandatory:true
  string_10 'zip',
             mandatory:true,
             upperCase:true
  decimal   'longitude',
             maxValue:190,
             minValue:-190,
             maxFractionDigit:4
  decimal   'latitude',
             maxValue:190,
             minValue:-190,
             maxFractionDigit:4
}

You should be able to read the code without much of an effort, right ? It looks like some detailed specification format, but it is actually the way you code an entity using SJS. What might be surprising when you first read this piece of code is the mix between :

  • state : string, decimal
  • appearance : icon
  • behavior : pageSize, toString
  • and contraints : mandatory, min/maxValue, …_64

This is because Jspresso tries to implement the DRY and CoC principles as much as possible. Displaying a country instance in a tree view ? Jspresso will use city-48x48.png. Building a CRUD view on countries ? a default page size of 50 will be used. Displaying a country in a form ? the zip field will look shorter than the name one and the field will not allow entering more characters than allowed. And so on… All this happen automagically but every decision made can be overridden at a lower level, like overriding the icon of the country for a given tree instance.

The same design principles govern all the Jspresso layers. Just remember that, although Jspresso will use sensible defaults when nothing is defined, you will always be able to refine them :

  • model : domain model entities
  • backend : faceless services and actions, transaction management
  • view : UI components, binding
  • frontend : view assembling, UI orchestration
form('City.form')
filterModule(
    'masterdata.cities.module',
     component: 'City'
     detailView:'City.form'
)
As simple to read as the previous example, no ? In this piece of SJS code, we define a form view which is able to display cities and we use it as detailView for a CRUD module (we call them filterModule in Jspresso). Afterwards, this module will be packaged in a workspace and all the workspaces will be assembled in the application.
Of course, in real IT life, nothing is ever as simple as assembling a set of simple CRUD modules; but it is often a good starting point. When you begin to improve your software — coding services, business rules and transactions, custom frontend actions,… — Jspresso will assist you in keeping a clean, modular and loosely-coupled architecture with all the plumbing hidden. You will focus on what’s adding value to your customers.

What qualifies Jspresso for a corporate environment?

Jspresso is built from the ground up with corporate challenges in mind :

  • Security : Secure your application with built-in authentication and authorization with pluggable schemes supporting SSO.
  • Internationalization : The framework itself is already translated in 13 languages and cleanly takes care of timezones, date and number formats, and even business data localization.
  • Integration : Expose your application by providing web-services on your back-end Jspresso services. Connect to the rest of the world using popular integration frameworks.
  • Testing : From unit tests to integration tests (using Tmar) and performance tests (using the Apache Jmeter plug-in), enrich your test harness to automatically assess your application before going live.
  • Evolution : Don’t get stuck to the decisions you make early in the project; they may, and can, evolve later. For instance, you can start developing against a relational database and change to a multi-node NoSQL store.
  • Monitoring, alerting and tracing : Integrate into your existing monitoring infrastructure through standard interfaces.

Jspresso prescriptive approach is a strong mean to standardize the development, increase your ROI and make your project resilient to turn-over and technologies (r)evolutions. Your existing Jspresso applications, when upgraded, will benefit from fixes and new features (mobile, cloud, NoSql, …) with little to no effort.

Industry standards are everywhere in Jspresso, from the design to the runtime as well as the build. Your projects will easily be integrated into your software factory including CI, DevOps, …