The QuariX Framework is the perfect web2.0 development framework for Progress and not only. Built on a solid MVC (model-view-controller) pattern, which allows loosely-coupling of interface objects, QuariX completely separates the user interface from the business logic and data access.
What differentiates QuariX from other Ajax frameworks is that QuariX besides being a collection of client-side objects has a well defined mechanism for object inter-relation along with a solid back-end run-time repository solution to assure the properly representation and interaction of those objects.
Our "smart" objects interact through an already proved publish-subscribe mechanism, the only valid choice in the asynchronous world of web2.0 applications.
The interface representation is described in a back-end repository and beside the initial screen "paint", all future communication with the server side business logic is reduced to "pure data" (XML request and JSON response).
The framework allows you to leverage your Progress developers knowledge and existing applications business logic (though, this should be completely separated from user interface) by keeping the business logic completely in Progress and providing an easy and rapid repository based interface design solution. To ease even more the development process the client-side objects were built to resemble as much as possible to the 4GL ADM2 Smart Objects, meaning that the base objects links are the same and we've tried to keep the same name for most of the functions when possible (especially for public ones).
Features
Beside the business aims mentioned before, technical implementation of QuariX provides something more even if some of those facts don't seem obvious from the end-user perspective:
great performances even over slow network connections by reducing the number of hits to the server and the data volume transferred between calls (most of the time it's only pure data);
scalability and availability support, based on Apache Tomcat and Progress Application Server coupled in a distributed architecture;
OS independence on both client and server side;
reduce the deployment time to minimum because of a single-place deployment and zero-footprint client which require no client updates;
greatly reduce the development time and allow back-end developers to use the client-side objects ainly through a set of well defined API's (in case custom functionality is required), without requiring the knowledge of complex Java Script implementation;
customizable themes for interface modern look and feel (CSS based);
repository based localization for easy maintenance (down to the user level);
repository based interface design for rapid application development ;
complete dynamic approach;
complete separation between user interface and business logic;
straight 4GL on the server side, a diversity of common development API's available: context, localization, security;
ease of customization by means of a series of already implemented developer hooks;
simple and straightforward, very easy to learn (no need of in depth web development knowledge).
Progress framework vs. Ajax framework
QuariX is not only just another Ajax framework being more than a simple collection of graphical interface objects that can improve the end user experience.
QuariX goal is to offer a simple to use and straightforward framework to help Progress developers to rapidly build rich and responsive web interfaces while requiring minimum web development knowledge.
Conceived from the start as a web2.0 framework for Progress developers, QuariX will help you leverage the knowledge of Progress ABL developers into the exciting world of web2.0 application development.
Scalable architecture
The architecture building blocks consists of application servers with proved scalability and fail-over capabilities which allows one to scale from a single machine installation to a distributed n-tier environment with load-balancing and fail-over support.
Progress Application Server running in a stateless mode is the central part of the system holding the whole application business logic. Beside this the Application Server is taking care of interface description (widget-based markup objects description based on repository), generic data-access layer provider and complete request routing management. Because of the stateless operation mode the Application Server can support a large number of clients with only a small spool of running agents.
Apache Tomcat server is used to effectively translate the widget-based markup language used for interface description in DHTML syntax based on QuariX rich-client framework. The powerful XLST translation process allows keeping a descriptive markup language for interface description and a better separation of presentation from the application business logic.
Powerful widget-based markup language
QuariX uses a powerful and straightforward widget-based markup language based on industry standards (XML, XLST). Following the latest trend in rapid application development models QuariX's object-oriented declarative XML markup language substantially increases the developers productivity enforcing development best practices that translates into dramatically reduced time-to-market.
Repository based application design
The QuariX Repository stores most of the application objects. The framework includes design-time or run-time rendering capabilities that can eliminate the need to create, compile, deploy, or maintain the source code for objects represented and stored in repository.
In order to support the ASP (SAAS) model, QuariX Repository allow multiple applications to be hosted on the same repository and run completely independent one of each other. In addition to application objects, the Repository stores a variety of additional information whether of general purpose or application related, including:
User profile data for user preferences;
Security data (only authentication for now, authorization at operation level is going to be implemented);
Application configuration data;
Localization data.
Generic reusable components
QuariX Framework implements a set of common application components with standard features that require no programming to implement (though programming can be required for customization in case standard behavior needs to be extended) providing most of the functions required for an application.
User Interface Objects
Available standard user interface components are designed to bring the rich interface users experience of common fat-client applications into web world and to provide a consistent and predictable look and feel of application interface. For even greater user experience QuariX implements the graphical user interface theme mechanism for all standard user interface components giving to users the freedom to choose the look they prefer (can be changed on-the-fly).
The user interface objects provide data visualization and control application functionality, a non-exhaustive list of available objects:
window - supports internal and modal options, can contain most other objects arranged in a table or flow layout;
container - can contain most other objects arranged in one of available layouts, offers multiple pages support controlled by tab panels;
field - multiple visualization options (fill-in, edit-box, check-box, radio-button, selection-list), data binding, customizable format and input data mask, attaching lookup browser for foreign-key fields as well as date-picker for date fields;
data grid - visualize multiple records from data object associated with navigation control;
data view - visualize a single (current) record from data object and accepts user changes;
form view - handle and control standard web forms, and form based data submission;
filter view - abstract component responsible of handling and control data filtering options on a data object
navigation toolbar - standard toolbar for data object navigation;
update toolbar - standard toolbar for input-output operations of data view.
All user interface objects are highly customizable using a set of extensible tags which allows changing the look of the object as well as its functionality if required. For example the command buttons of standard toolbars can be hidden as required; can have the icon changed, the tooltip or action to perform (this can be calling a custom Java Script function, evaluating an URL or simply publishing an event).
Data Access Objects
QuariX implementation of standard data access component include both the back-end part for actually data access layer and the client side representation that allows decoupled data access with complete separation of user interface from data access layer. Because of the mixed technology the two components of the Data Object uses an efficient and well defined communication mechanism based on standard formats: XML for client requests, JSON for server response.
Standard operations are implemented to handle records retrieval as well as update operations: adding, removing, editing records. Communication between client and back-end sides of Data Object can be reduced to two basic operations:
retrieve data, using a record batching mechanism with support for filter and sort options as well as calculated fields
save changes, only send changed records including before-image data.
Standard functionality can be overwritten using developer hooks triggered before and after certain events: batch update, batch fetch, etc.
Native localization
QuariX Framework offers native support for localization which includes:
translatable applications, multiple-languages support (labels, messages, all translatable strings);
localized numeric, date and logical data representation (American, European);
localized input masks for numeric, date input fields.
All translatable strings of an application can be translated and each application can support one or more languages (default language can be set at application level). For a multi-languages enabled application the user have the freedom to select the language he prefers, the preferred language can be set in users preferences as well as all other localizations preferences.
QuariX supports both the numerical and date formats available in Progress meaning that:
the data representation for a numerical field can be either in European (1.000,00) or American (1,000.00) format;
the data representation for a date field can be in one of the following formats: mdy, dmy, etc.
Not only that QuariX supports localized data representation but this holds also true for input mask validation. This means that for a numeric or date field the input data is validated and actually formatted 'as-you-type' using the localized field format.
Versatile Service Managers
In order to manage the objects defined in QuariX Repository as well as common features of an application, QuariX Framework provides a series of service managers. Each manager is implemented as a persistent procedure running on Application Server and instantiated by the framework at agents startup.
QuariX Framework implements the following standard service managers:
Localization Manager;
Repository Manager;
Security Manager;
Context Manager (request, response, session).
Integrated Report Engine
Because reports are important QuariX has successfully integrated BIRT which is an Eclipse-based open source reporting and charting system for web applications.
BIRT has two main components: a report designer based on Eclipse, and a runtime component that is integrated into the QuariX broker.
Some of the features of the QuariX report engine:
Data - Databases, Web services, QuariX DAO (Data Access Objects), JDBC, XML, Flat files all can supply data to your report. Further, a single report can include data from any number of data sources. The report engine also supplies a feature that allows disparate data sources to be combined using inner and outer joins.
Data Transforms - Reports present data sorted, summarized, filtered and grouped to fit the user's needs. While databases can do some of this work, the report engine must do it for "simple" data sources such as flat files or Web services. The QuariX report engine allows sophisticated operations such as grouping on sums, percentages of overall totals and more.
Business Logic - Real-world data is seldom structured exactly as you'd like for a report. Many reports require business-specific logic to convert raw data into information useful for the user. If the logic is just for the report, you can script it using JavaScript.
Presentation - Once the data is ready, you have a wide range of options for presenting it to the user. Tables, charts, text and more. A single data set can appear in multiple ways, and a single report can present data from multiple data sets. The curent release provides web output as a single HTML document, paginated PDF, XLS, DOC, PPT, and Postscript.
Internationalization - The web allows worldwide access to your application. The report engine provides excellent support for internationalization and localization.
Text Localization - You can create a single report that automatically displays strings in the user's language. All labels and report text can be externalized and translated using the standard QuariX internationalization and localization repository.
Localization - provides locale-aware data formatting, meaning that a date can appear in mm/dd/yy format for US users, and dd-mm-yy format for Europeans.
Dynamic Formatting - Chinese text is very compact, German is often quite lengthy, and English of medium size. The report engine automatically adjusts the size of report items to fit their content to avoid the need to test the report with every possible translation.
For more information or details please contact us at:
Data Transforms - Reports present data sorted, summarized, filtered and grouped to fit the user's needs. While databases can do some of this work, the report engine must do it for "simple" data sources such as flat files or Web services. The QuariX report engine allows sophisticated operations such as grouping on sums, percentages of overall totals and more.