2 Introduction
Carousel is a Java and XML framework for creating applications with rich user interfaces.
Carousel includes a plugin for the netBeans integrated development environment making the development and testing process as easy as possible without locking you into a proprietary solution. Carousel also has a rich set of libraries, tools and wizards for rapid application development.
Note: XUI (pronounced zo'i) is the open source platform upon which Carousel is in part based. Carousel greatly extends XUI and includes many features and facilities not available in XUI. Much of this document can be used as a reference for XUI. Features and chapters specific to Carousel will be noted at the start of each affected section.
|
What is Carousel?
First and foremost Carousel is a framework for building Java and XML based applications. The aims of Carousel are to:
Reduce the amount of code needed to build an application
Provide a clean application architecture and infrastructure
Simplify building and maintaining applications
Allow easy extension and customization
Enable lightweight and performant applications
The core of Carousel is a small Java library that allows 'pages' of an application to be constructed from an XML declaration or from Java code. Carousel offers many add-ons and extensions including a graphical editor/IDE.
Carousel is commercial software extending the free open source software (FOSS) editor offered under the Xoetrope Public License (identical terms to the MPL) as part of the XUI platform. This license allows for Carousel to be used in commercial applications without the restrictions of some of the more common OSS licenses.
The relationship between XUI and Carousel is shown below. XUI builds upon the Java platform, Carousel builds upon XUI and in turn your application can build upon all of these technologies.
Carousel can be used for simple single page applications and forms or for complex business applications comprising many page and resources.
What can be built with Carousel?
Carousel can be used to build a wide variety of applications just a few of which are listed below:
Simple form based applications
Catalogues, Configurators, Browsers
Selection tools
Guides/Brochures
Retail and Point-of-Sale applications
Kiosk applications
Mobile applications for field workers and road warriors
Surveys and market research applications
Database applications
e-learning applications
Informational and promotional applications
Carousel is a general purpose tool so it can be used to build just about anything you can imagine building with Java and XML, but it offers the greatest advantage when building client side applications.
Carousel also includes many sector specific features and add-ons. The Xoetrope website has a full list of the add-ons and case studies highlighting how Carousel's has been used to build specific solutions.
What does Carousel do?
In a nutshell Carousel can be used to build feature rich, smart-client applications. Smart client applications are typified by their ability to make use of client-side computing power. Notably this means that such applications exhibit;
A feature rich user interface
A fast and responsive user interface
Ability to work on-line or standalone
A simplified application construction
Ease of updated and processing of dynamic content
Built-in data management
Sophisticated functionality
Optimized bandwidth usage
Low maintenance and administration characteristics
All of these features can be found in Carousel built applications. Furthermore, being Java and XML based, Carousel applications are portable so that they can run on a wide variety of devices and platforms.
As a development platform Carousel leverages the usual drag and drop techniques to make building applications quick and easy. Carousel includes numerous widgets, library functions and wizards to make many common tasks simple.
Simplicity really is the key to Carousel, so even if the feature or behavior you desire isn't predefined it usually isn't difficult to implement. As an open system Carousel even allows such additions to be made in a reusable way so that you may only need to define the addition once. Even if you need to go beyond Carousel's capabilities you can work directly with Java and XML or with third party tools. So, ultimately Carousel make the developer's life easier.
How does Carousel work?
Carousel takes advantage of local computing resources. So, instead of going back and forth to a server a Carousel application can store and process information. As a result you don't see the delays that are typical of some web-based applications. Using the local computing resources means that you can make an application more responsive, offer more and better user interaction and build smarter applications, so-called rich-client applications.
Making use of local computing resources also helps simplify some of the tasks involved in building modern software applications. If you don't have to go back and forth to a server for information you don't need to do so much to maintain state information. Furthermore if you can eliminate input errors at source then your business processing should be less complicated.
In addition to the implicit benefits of a rich-client framework Carousel also applies some well known architectural techniques to further simplify the process of building applications. The most important of these concepts is the Model-View-Architecture (MVC) pattern. With this pattern the key components of an application are separated from one another to simplify development. In Carousel the MVC architecture is promoted by the natural separation of the various components in framework and by the coding styles and techniques used for each component.
The Carousel MVC components equate to
View: Pages defined in either XML or Java.
Model: The data, declaratively bound to the pages or view.
Controller: The application logic specified in Java and declaratively bound to the other components.
Carousel also supports declarative user interface specification and declarative data binding whereby pages, data bindings and event bindings can be specified in XML independently of one another. The late coupling this provides has a number of benefits. Pages can be delivered or updated independently of one another much like HTML pages. This sort of independence of content was one of the major benefits of thin-client and web applications yet Carousel manages to deliver similar behavior and benefits in a rich-client framework. Carousel however achieves this while leveraging the Java platform, in the process delivering efficient, modular and reusable components.
Much of Carousel's benefits stem from this loose coupling of components. Since the View is loosely couple to the data model a new look and feel can be placed on an application with minimal implications for the application behavior or coding. Similarly the application logic can be coded with minimal reference to the user interface or how data is bound and update to that user interface. Imagine being able to write the code for even a simple equation without having to know when or how the input fields are filled out or how to then display the results of your calculation.
The separation of roles pays dividends in a number of ways. People of differing skills can collaborate on a project with perhaps one concentrating on the user interface and visual side while another may be responsible for business logic or data processing. Whether this is actually a realizable business benefit is a moot point, but in the long-run the benefits are very real.
In a maintenance mode it may be many months since a particular feature or aspect of an application has been developed. Being able to 'fix' a bug in say the business logic in such a feature is considerably easier when you don't risk breaking a user-interface feature or the data setup or vice versa. Furthermore without mixing user-interface code and business logic the role and intent of each piece of code is more apparent and this make understanding each part of the application a little less involved.
Carousel is in some senses is a fairly typical development environment or framework for building Java applications, a plug-in for the NetBeans IDE is even a key feature. Carousel however aims to make the process of building and maintaining applications as simple as possible.
Using the techniques described above Carousel eliminates much of the normal 'plumbing' code and allows you to get on with building real value into your application. In saving large amounts of coding the burden of developing and maintaining applications is also greatly lightened.
If you were logged in you could rate this article or add a comment.
;)
;)
;)