warning this documentation is still somewhat incomplete. We are working hard to improve both the feature set and the documentation. So do have a browse around, but definitely come back later to see how things evolve.
equanda is a tool which should help you to build enterprise grade (J2EE based) application with minimal effort, focussing not only on the initial version, but considering that most of the cost will be in maintaining and evolving the application.
This is done by generating as much as possible directly from an XML description of the the data and interactions (the domain model or "dm"). Some more thoughts about the concept (generation) can be found here.
There are many ways to enhance/improve the generated application, but this is always done in such a way that most changes in the domain model don't cause any problems. You just recompile (which re-generates all the files which needs modifying) and all the manual changes are preserved.
The idea is that application development should be focussed on doing the important stuff (the unique features of the application), and that common aspects should only be done once (even more so because this improves consistency). The goal is to work towards a vision of how application development should be (original thoughts in this blog).
In equanda, the definition of the domain or domain model is very important. This is a (xml) description which contains your data structure enriched with possible declarative constraints on your data, hints for the user interface, information about user rights etc.
From this model various aspects of your application can be built. This is done using code generation based on Velocity templates. The templates are written in such a way to allow programmatic customizations and extensions without affacteing the generation proces. So when your domain model changes, you can just re-generate your application. The changes in the model will be propagated and your customizations will still be in place. No cut and paste or other manual labour is needed.
equanda is built to have many aspects where flexibility is offered, to allow you to choose what kind of application is built.
Some examples :
equanda is intended to help you build enterprise grade (business) applications with minimal effort.
The application can run in a client server environment and can be deployed on several tiers.Specifically, you could deploy the web server, the business tier and the database on different machines. Moreover, while the business tier needs to have access to the database tier, the (web) client tier only needs access to the business tier. This way it is possible to secure that all access to the database is forced through the business tier and to ensure that all the constraints which are enforced by the business tier cannot be evaded.
Internationalization is built into the system. All the information in the system can be translated, both the messages on the user interface and the error messages. There is specific support and tools to manage the translations. This to allow separate people (non-programmers) to manage the translations without the properties hell (where you have translation in tens or hundreds of properties files).
The generation has some extra support for useability. There are efforts to make the templates as readable as possible, but to aid you the generated (java) files can be source formatted, the generated xml files can be formatted and/or validated. However, in both cases this can be disabled as well (to make generation faster).
The following aspects of the application can be generated.
Domain model description options
Implementation
As a bonus, when your client only uses the proxies, it is straightforward to replace the backend (this way the data could for example be based on webservices instead of EJB3 entity beans).
More details about the generated EJB3 persistence layer.
(*) ^Items marked like this are available in the old tapestry4 version and will be available again for the tapestry5 version.^
More details about the generated tapestry5 user interface.
equanda uses an internal mechanism to configure the very granular access rights for the user interface. This is based on user information in the database. This module allows you to generate a login module which prevents duplication of user information between the application and the JAAS module.
More details about the generated user management support.
It is possible to generate code which can be used to import data from a CVS-like text file.
More details about the generated import data.
This allows generation of a tool which handles database update (and optionally partial cleanup).
More details about the generated ddltool.
Documentation for the domain model can be generated. This includes html documentation, a Freemind mindmap and owl.
More details about the generated domain model documentation.
equanda contains several modules.
History of the project.