The Atris Framework makes use of Java and the Java/Swing API to simplify the development of GUI based applications. These applications can be run on ANY computer platform and operating system that supports the Java language (which includes all of the principal operating systems in use today). This means for example, the a developer can create their program in a Microsoft Windows operating system environment, and have it run on any GUI based interface, including Linux, Solaris, Mac-OS, etc. without making any changes to the code. This gives the developer access to many more platforms for their software and a write once, run anywhere ability.
Although Java/Swing is a rich GUI development language, it does not provide
many of the usability 'features' that most GUI users have come to expect. In
addition, the Java API set, although rich and extensive, does not unify the
various persistence models of 1, 2 and 3 tier client/server architectures into
a singular reusable model. Accordingly, the Atris Framework delivers this ability
by simplifying the development of such applications for the developer
by providing many of these expected features in a unified Framework. The
Framework itself is focused on a subset of applications that can be written
with Java. This subset includes most GUI applications that require the
persistent storage of data either locally or remotely. The following sections
will provide more details about the frameworks capabilities.
Loosely coupled architecture
The Atris Framework is based, in part on the principal that a loosely coupled system, where appropriate, is easier to design, develop and maintain, all other things being equal. Accordingly, the framework is divided into functional 'layers' each responsible for a part of the entire application. The connections between layers are dynamic, where changes to one layer, even at the interface level, has a minimal impact on the framework itself. This is achieved through the use of the Java 'Interface' construct, and through the application of the guiding principals of reusability through containment (encapsulation). Inheritance, in its classical form is avoided where possible, and only used where there is a direct non-trivial relationship between the parent and child classes.
The framework is built from the Java API and is thus inherently platform independent. This independence of platform allows developers to build sophisticated GUI applications with all of the features that users have come to expect, and still retain the ability to have their code execute on other platforms and operating systems. This gives the developer a greater 'reach' with their applications, and avoids limiting the potential audience of the program to a subset of the true user domain. In addition, by unifying the application to a single code base, the developer eliminates the need to maintain multiple versions of code for different operating systems, and thus lowers development and maintenance costs of their creations.
Simplified Deployment, avoids Browser based GUI simulators
Using the Java infrastructure and the 'Java Web Start' technology, developers can create applications that can be launched from a desktop via a click of a mouse button, and have that application check for the latest updates on a remote server, automatically updating the local version of the application if a newer version was found. Moreover, the developer can create web pages with these links that allow the user to automatically install applications that will always be up to date. This technology eliminates the need for developers to deploy new versions of their applications to the end users; the update process is inherent in this technology. The process is also secure, in that the developer can also 'sign' the application with a certificate to ensure that it is authentic.
In addition, this technology allows developers to deploy windows GUI applications an order of magnitude more sophisticated and easier to use than Web based Application interfaces. A Web interface lacks the expressive power of a true GUI interface and does not make a very effective interface platform for non-trivial interfaces.
A great deal of work and money is expended on trying to get Web interfaces to behave like a windows-GUI interfaces with little success. Web interfaces are document oriented and liner in navigation, most GUI based applications are window and task oriented. The Atris Framework allows the developer to create a true Windows-GUI interfaces that can be launched from a Web Browser, but leave behind the constraints and distractions of Web Browser interfaces to deliver a truly usable application to the customer and end user.
n-Tier persistence Model
Almost every non-trivial application requires the storage of data and information to a persistence storage medium at some point in its use. This storage medium can range from a single local flat file to a complex, remotely accessed relational database. These different forms of persistence models are often referred to as the 1-tier, 2-tier and 3-tier client/server architectures (often termed collectively as n-tier architectures). A 1-tier model stores the data locally, (either to a local file directly, or through a simplified local database. Examples of such an application would be a word processor, where the document is the persistent data). A 2-tier client/server architecture is the most common in use today. This architecture involves a local client application and a remote database server. The last model a 3-tier architecture involves the use of an Application Server to house business logic. The Atris Framework unifies these three different types of persistence models into a single layer. This has the effect of decoupling the Presentation layer completely from the layer that handles access to the data. Developers can then create robust applications that are unaffected by the implementation of the data model.
A Design pattern, for the purposes of the Atris Framework is a reusable template that can be adapted for a specific application. Design Patterns simplify the design and development process by providing a ready-made screen component that can be plugged into the development process. Moreover, by taking advantage of the provided design patterns, the developer can achieve consistency in interface design. The Atris Framework makes available to the developer many design patterns to simplify the development process.
Advanced Screen Editor
The Atris Screen Editor allows developers to create GUI screens quickly and efficiently. The screens are saved in an XML format that is compatible with Java 1.4.x and above, allowing the screens to be reloaded even outside of the framework. When used within the framework, the screens are used to bind the data layer with the presentation layer in a way that drastically simplifies the mapping process between the screen and stored data. The screen editor itself provides advanced features such as property editing, smart drag and drop capabilities, true what you see is what you get visual display of the screen, dynamic resizing and moving, group based functions, including alignment, color and image settings to allow customization, and even the import of other JavaBeans libraries and their JavaBeans objects.
Standardization and Consistency
The Atris GUI Framework is designed to handle many of the routine tasks and functions that a standard GUI interface provides to users. For example, tiling of windows, remembering the position and size of windows, automatic logging into databases, handling of application look and feel, the management of application properties, automatic search and sorting of data and a host of other house keeping tasks. By providing all of these and many more, the framework drastically simplifies the work that developers must do, while ensuring that every application developed with the framework maintains the identical look and feel, thus simplifying end user training.
The Atris Framework includes over 400 pages of extensive documentation that provides details to the developer from everything from the concepts and architecture of the framework, to actual examples and tutorials of how to use the framework to create sophisticated applications.
The Development guide details the design and architecture of the framework, providing detailed diagrams and notation on the theory and application of its operations. While the tutorials provide extensive examples and source code. The documentation on the screen editor provides the user with screen based instructions on how to use the various features and capabilities of the screen editor to get the most usefulness from the application. While the Setup and installation guide provides detailed instructions on how to install and use the framework in various environments.
Lastly, this web site provides additional resources and services that developers can make use of, including additional code samples and examples, application use as well as discussions on theoretical subjects of design and specific articles highlighting specific key aspects of the framework.
Royalty Free, open Source