RapidApps technology consists of tools and APIs that provide a framework to generate web applications much faster than conventional development methodologies.
Each component offers significant advantages over competitive components in the marketplace.
Integrated together they provide us a fast and easy way to generate web applications for you.
Perhaps more important than the details of the component is our development philosophy.
- Simple solutions are better than complex solutions.
- Responsibility for a task should reside in one file.
- People with different responsibilities should not edit the same file.
- Changes to the browser code should not require changes to the server code, unless the business logic changes.
- Changes to the server/business logic should have minimal impact on the browser code.
- The best software is made from reused software components.
While these are simple "rules" that reduce the "friction" between components (and developers) none of the existing frameworks follow this philosophy.
Java developers know how complex enterprise applications can be.
Java frameworks are complex and the different components take significant code to integrate with each other.
There are many friction points between different components of the common frameworks.
Following our philosophy and eliminating these friction points pays huge dividends in development productivity.
Using our framework we can develop applications up to an order of magnitude faster than conventional development.
The resulting code is standard JavaEE code and can be costomized and maintained with any Java IDE.
RapidApps technology is focused on the server-side. We make no assumptions about the client-side (other than the standard http request and response protocol).
This means any client side technology can be used with our server technology. If our customers want to maintain or change the presentation of the application with their favorite HTML/CSS tool, that is not a problem.
We use (what else?) a web application built with RapidApps, to build web applications. This tool helps us to quickly capture the user requirements and store them in the repository.
As each "functional set" of interactions (forms, queries, tables and reports) are defined, the business objects and servlets are automatically generated to provide the required functionality.
In addition we have a number of tools for automating application development such as an HTML include processor which reduces the effort and improves the quality in generating the HTML pages.
RapidApps completely separates the browser and server code. No server side code in the browser code. No browser side code in the server code.
Web designers can freely edit the browser code without having to step over server code and Java developers don't have to worry about any HTML/CSS in their server code.
The client and server sides are connected by the meta data. An HTML (client-side) form is represented in RapidApps by form meta data which includes the field names and validation parameters.
enables persistence of business objects. The following is a simple example of saving purchase order information that has been entered into a form and then is a separate session retrieving the data.
PurchaseOrder po = new PurchaseOrder(PO_Number) ;
// ... add aditional PO information
// to select the purchase order
PurchaseOrder po = new PurchaseOrder(PO_Number).select() ;
String companyName = po.getCompanyName() ;
Most SQL databases are supported (where JDBC connector is available).
has modules to import data from various sources. These modules greatly speed the migration of existing applications to a web application.
- MS Excel Import - Imports .xlsx files and generates data entry, update, delete, query and report interactions.
- SQL Database Import - Imports SQL schema (text file) and SQL databases. Generates data entry, update, delete, query and report interactions. Can access the database in parallel with existing applications.
- HTML (forms) import - Imports existing website HTML and extracts data entry forms. Generates data entry, update, delete, query and report interactions for the forms.
To minimize the "glue" required to bridge between the front-end (interaction) code and the back-end (server) we have made the frameworks very compatible and provide bridging functionality that simply transforms a "form data object" into a "table data object" and back again.
The net result is the java developer can get data from a form, validate it, save it to the data base, and retrieve other objects like it and return them to the browser, in just a few lines of code.