XTT offers superior end-user experience by delivering Enterprise Class rich user interfaces that can easily be built on top of new or existing systems. An XTT application provides developers an ultra-thin application that can be easily deployed over any network including the Internet. End users using applications developed with XTT will have the same experience that they are accustomed to in desktop applications. XTT based applications offers the following features to the end user:
Applications built with XTT drastically increase the return on investment by a combination of:
The XTT framework enables you to develop and deliver solutions at least 75% faster than by other means. XTT is able to achieve these productivity gains by the use of the Form Wizards. The Form Wizards allow for rapid point and click construction of functional java forms, no Java coding required.
XTT abstracts away tedious infrastructure work and allows the developer to focus on the application business logic. XTT provides all of the "plumbing" necessary to build true enterprise-class applications by providing the following major components which minimize the time required to develop an application:
Even though development is done in NetBeans or Eclipse, the 'fat' IDE framework is not needed at runtime. This keeps the application very thin and easily deployable.
The XTT architecture also actively encourages developers to take advantage of and use any existing Java libraries, standards, and 3rd party components, to accelerate development of their Java projects. Third-party components can be used either "out-of-the-box" or they can be completely integrated into the XTT framework by extending them and implementing XTT-specific interfaces.
Another key feature of XTT is the automated data marshalling and synchronization which allows developers to focus on writing their business logic.
Extend the life of your existing assets by building distributable web based applications that can be used over existing WAN infrastructures. Provide scalable applications that make use of existing disparate data sources without having to first migrate solutions to one platform. The only requirement is that the data source is accessible through Java.
For example a major healthcare company is using XTT to rapidly develop a single consistent user interface for customer service which used to require the navigation of five (5) separate applications in order to provide real-time customer support.
On the server-side developing an XTT-based application is the same as what you would normally expect: using NetBeans or Eclipse IDE to write application-server side business code like EJBs, web services, security implementations, etc.
On the client side, if you already know Swing you will be very comfortable with XTT. If you are new to Swing, XTT's wizard-based approach to application development will help you get started with Java Swing very quickly.
Java developers will be comfortable with the XTT Framework since it is nothing more than a simple set of Java API's. Most of the client-side development starts with a wizard that generates a visual form that you further edit using NetBeans or Eclipse.
The forms built with XTT are ready to use as is. To further enhance XTT based forms developers will used their existing skills to modify visuals forms through drag and drop, or add custom validation logic or connect forms to server based business logic, etc.
Lots of companies are using Citrix to deliver LAN based applications to remote users, this method has been popular due to the fact that you are simply remotely running the existing application, therefore there is no need to re-write the application. Unfortunately, this option doesn't scale very well unless you are willing to invest in a lot of money in recurring licenses and hardware to support it. With XTT you would have to build the User Interface in the XTT Framework, however the VB/PowerBuilder-like development environment minimizes this expense and the automatic data binding and synchronization significantly reduces risk.
XTT based applications require fewer servers to service the same number of users as compared to Citrix or even a Java Script browser-based solutions. Depending on how you architect your solution using XTT you can save even more licensing fees by using open source J2EE application servers like Tomcat and JBoss.
XTT also employs a concurrent user model with a low per user cost thus providing a more cost effective solution than the Citrix's named user licensing model.
XTT focuses on rapidly both prototyping and developing very rich, thin, web applications. Development is done in either NetBeans or Eclipse and consists of a combination of wizards, drag and drop visual editing, setting properties for visual controls, writing events where needed, as well as connecting to business logic using standard Java.
Because XTT manages the infrastructure, architects and developers are free to concentrate on the business logic and flow of the application.
This approach vastly reduces the amount of code that the developer would have to write, and drastically enhances the robustness of the application as there is minimal or no infrastructure code for the developer to manage. On the other hand, the developer uses a standard IDE, the standard Java language, and has full access to all the productivity tools that the IDE offers from debugging, Java EE (J2EE) helpers, familiar editors, packaging, deployment, etc.
The XTT framework is built on the J2EE/J2SE framework which is considered the de facto standard for scalable, secure, industrial strength applications.
Since XTT is pure Java on both the client and the server, it is operating system and browser independent and therefore will not be obsolete as technology evolves. XTT does not lock you into the use of a specific IDE or the use of a fixed set of visual controls or is only compatible with certain data sources. In fact XTT provides a very open API interface for integrating any third party library into the XTT framework therefore opening the developersí choices to truly be able to deliver a best of breed solution.
Since XTT uses standard Java, no proprietary application server or other infrastructure software is required. XTT simply needs the standard JVM to be loaded on the client machine (1.4 and above).
XTT is a mature product (current version 5.4); first production XTT based applications went live in 2001.
Architecturally, XTT plugs into the Java EE (J2EE) stack as the top two tiers of an n-tier application. XTT provides automated data binding to virtually any SOA persistence layer including EJBs, POJOs, Web Services, server-side Java Classes, or JDBC.
The server side component of XTT was designed to run as a servlet. This enables XTT to take advantage of the business and data layers (EJBs, web services, persistence layers, database connection pools and java classes) in the application server. The XTT server is then responsible for streaming data from those sources to the remote XTT clients over HTTP. XTT also takes full advantage of the other features of the application server like: clustering, security modules or integrations servers.
Because of the Java smart client, many of the actions that would traditionally have to be handled by a server can now be handled in the client tier (like: data validation, sorting, filtering, etc). This eliminates a huge amount of requests from burdening the application server, which in turn can now allow a much greater number of users to be supported. This leads to direct savings as the number of servers (including hardware costs and licenses for their software) required to support the application can be reduced.
Additionally, XTT based applications use very little bandwidth because once the thin client Java application is downloaded to the client machine all that is transmitted back and forth is data over HTTP.
Since XTT allows developers to distribute logic to either the client or app server depending on where the code would run most efficiently you can easily create applications that will continue to operate when disconnected from the Internet. The XTT application can persist new data on the client until such time that it can be re-synchronized with the application server.
XTT applications can be designed to gracefully deal with a loss of the Internet connectivity. If the application becomes disconnected either by accident or design, the user can have the option to save their data locally until the connectivity is restored and that data can be synchronized with the server again. In a browser based solution this is not an option. Browsers were simply created for browsing.
Publish/Subscribe is an asynchronous messaging pattern. In Publish/Subscribe, publishers post messages with specific “topics”, rather than sending messages to specific recipients. The messaging system then broadcasts the posted messages to all interested parties (subscribers).
XTT supports the Publish/Subscribe mode through the XTT feature called Server Push. This feature allows the remote client application to register with the server and be notified immediately when an event is triggered there. The Server Push feature removes the extreme load that the server would be experiencing due to continuous polling from many clients.
We have devised our licensing model so that it can be scaled to accommodate either an enterprise class or a limited connectivity license depending on your specific application needs.
Limited Connectivity -The Light Connectivity license is issued to the application server's IP address and allows between two (2) and thirty (30) simultaneous users. The Light Connectivity licensing model offers a flexible solution for developers and end-users of business applications that do not require unlimited concurrent connectivity.
Unlimited Connectivity - The Enterprise Class license is issued to the application server's IP address and allows an unlimited number of simultaneous connections.