 |
Product Overview |
Galileo applications are client-based (require no server-side components) Java applications that run within a single HTML web page and are accessed and loaded in the same manner as a traditional web page. They provide all the features of a standard HTML-based web page plus a host of additional features that include asynchronous data transfer, advanced UI controls, application skinning, drag and drop, animation, custom graphics and advanced XML processing.
For end-users Galileo applications provide a much richer and more efficient web experience. For developers they offer the opportunity to employ more traditional software programming practices by replacing the maelstrom of technologies currently needed to develop Rich Internet Applications with a single, object-oriented technology that is used like a traditional programming framework. By providing a flexible and easy-to-use API and a comprehensive control library that includes controls that are common to desktop and rich internet applications, Galileo allows developers to focus on what they want their application to do without wasting valuable time figuring out how they are going to do it.
Comprehensive Component Library
Galileo provides a comprehensive set of rich UI components that includes all the elements offered by the
basic HTML element set, plus an array of additional components common to desktop applications and
Rich Internet Applications. The following components are included in the Galileo framework:
|
|
|
Open Source Controls
In addition to the components that are built into the Galileo framework, Galileo will also provide
a library of open source controls individually downloadable from our website. These controls will
be more specialized and therefore not part of the standard library avoiding unnecessary bloating
of our framework byte-code. These controls can be integrated into your own application code -
used as-is or freely modified to suit your needs.
Modules (future)
Modules will be sophisticated groups of controls that
provide the UI functionality of a common website service such as a
blog, message board, wish list, etc. These will separate libraries available
from our website that can be plugged into your existing
Galileo application just like any other component.
Extensions (future)
Extensions will be additional code packages providing extended capabilities
for Galileo such as data graphing.
Scriptless AJAX and SPI
Traditional web pages rely on the web browser to send and receive HTML requests generated
by user interaction. Whether the purpose of the request was to simply modify the interface or
to retrieve a small or large amount of data, the browser paradigm requires that an entire web
page be loaded in response to the request. This is referred to as a Multi-Page Interface(MPI).
AJAX (Asynchronous JavaScript and XML) is the term that is used to refer to the technique that
allows web pages to perform asynchronous HTTP requests using the JavaScript XMLHttpRequest object.
Web pages that are developed using AJAX can retrieve text, HTML, or XML data from a web server
without causing the browser to reload a new web page. In most cases this allows web sites to
operate much more efficiently by updating only the portion of the web page UI that was affected
by the request. Web pages that operate in this manner are referred to as Single Page Interfaces (SPI)
or Single Page Applications (SPA) because they behave more like applications than traditional
web pages. Galileo provides the same ability to transfer text, HTML, and XML data asynchronously
through HTTP requests as AJAX does, but does so using the Java programming language instead of
JavaScript.
Smart Navigation
Galileo's Smart Navigation is a great feature; it allows developers to
create links to application components that are similar to HTML
hyperlinks. When a user clicks on a Smart Navigation link the framework
locates the targeted UI component and displays it no matter where it's
located in the application's UI. For instance, if the component that is being navigated
is embedded several levels down in your UI component tree and none of the component's
ancestors are currently visible, the Smart Navigation system will adjust the display state of
all the components in the referenced component's ancestor tree in order to display it.
We think this is pretty powerful stuff. It allows developers to create very loosely coupled
components that can be restructured in any way they see fit, without having to update any links
to those components. It also allows developers to provide end users with the ability
to jump from one location to another in the application's UI without requiring them to remember
any elaborate navigation paths and dismisses the need for developers to explicitly program
UI navigation paths into their application. The Smart Navigation feature also allows Galileo
applications to behave like traditional websites in reference to browser navigation actions
(back, forward, and bookmarking) making Galileo application navigation behavior indistinguishable
from traditional website navigation from an end user's perspective.
Drag and Drop
Galileo's Drag and Drop capabilities bring a common feature available to desktop applications to your
website. Drag and Drop adds a level of convenience to your application for
end users by reducing certain input steps that might require several user actions to a single user
action. While Drag and Drop gives your application a sophisticated look and feel,
its real benefit is utilitarian in nature allowing graphical representations of your data to be easily
manipulated by your end users.
Style Sheets and Application Skinning
Galileo provides CSS-like styling features that allow easy styling of all application controls
and the creation of application dkins that can be used to customize the look and feel of your
application. Controls contain all the style attributes that are available to HTML elements via
CSS and many additional attributes which aren't available in HTML. Galileo style attributes
include Shape (rectangular, elliptical, and rounded rectangular), Shadow (depth, transparency,
angle, and blur), Background (color, color gradients, images, and code-generated graphics),
Font (color, size, family, and weight), Border (color, thickness, and style),
Transparency (full or background-only), Padding, Overflow, Cursor type, and various sizing and
positioning attributes. Additionally, Galileo controls have built in state which allows different
style attributes to be assigned to different states giving controls inherent dynamic behavior.
Animation
Galileo provides a simple, but powerful animation package that allows you to apply time-lapsed
changes (Effects) to any component. Basic effects such as resizing, moving, and fading are provided
in addition to more sophisticated effects that can be used to give your applications Mac or Vista-like
behavior. In addition to Effects, there are several other classes that can be used with Effect
classes to apply multiple effects to a component or to create complicated sequences of effects
on multiple components to create animated scenes.
Custom Graphics
Galileo provides components that allow the integration of low-level AWT graphics programming for
applications that require advanced or custom graphic generation. Graphic components are also a
convenient alternative to using images for graphics that may be dynamic in nature.
Intuitive and Efficient API
Galileo's API was designed to be intuitive, efficient, and flexible. Most classes in the Galileo
framework have what we refer to as a Dual API. By this we mean that most classes have two sets of
methods. One set, the Simple Interface, is a high-level interface that allows developers to do the
more common and basic operations with a single call. The Simple Interface makes it extemely easy to
start using Galileo. Developers can jump-in and start creating applications with only a basic
understanding of the framework. The second set, the Advanced Interface, is a low-level interface that
gives developers more control over the fine-grained details, but may require a little more code and a
better understanding of the framework.
Robust Architecture
Galileo has a robust architecture that was designed explicitly for the following purpose: to
quickly and easily build highly customized, dynamic, and interactive browser-based internet
applications. But quickly and easily does not mean you have to sacrifice software quality.
With an object-oriented design that has evolved over many iterations, Galileo's architecture
supports modular, loosely coupled designs that promote generalization and highly extensible,
maintainable, and reusable application components. This makes Galileo ideal for Enterprise
applications that require a significant amount of collaboration between team members allowing
easy integration of software components and application content.
Cross-browser Congruity
Galileo applications run in all major browsers on all major platforms. Unlike HTML/JavaScript-based
frameworks which have problems displaying RIAs consistently on different browsers, Galileo
applications look and behave identically on all the major browsers (Firefox, Internet Explorer,
Safari, Chrome, Konqueror, and Opera).
Client-Based
Galileo applications are client-based which means that your application code is downloaded to
the end-user's machine and executed via the Java web browser plugin. All user interface processing
is handled by the application itself and therefore processed by the end user's machine. This is in
contrast to server-based applications which send user interface events to a web-server for processing,
having to wait for the server to handle the events, make the decisions for any UI updates that
are needed, and to finally send the response back to the browser. Client-based RIAs tend to be much
more responsive then server-based applications since UI changes do not require a client-server
round trip to fetch the new UI code. In addition, client-based applications reduce the overall load
on your web server since server responsibility is reduced to data-serving only, increasing the
scalability of your RIA. Client-based
applications are also independent of your back-end technology allowing you to use any server-side
technology that you choose to handle your data requests.
Inherited Java Features
In addition to all the features that we have explicitly built into the Galileo framework,
developers also get all the standard features of the Java programming language and its core
libraries: inheritance, polymorphism, and encapsulation; strong type checking; enumeration
types; multi-threading; exception handling; dynamic collection classes; XML parsing, translation,
and validation; regular expressions; advanced graphic capabilities; internationalization and
localization; and security features.
Free for Non-commercial Use
Galileo costs nothing to download and use for non-commercial purposes. For commercial purposes you
can download Galileo and develop applications with it for free, but a deployment license is
required to deploy those applications.
Galileo allows developers to easily develop sophisticated user-interfaces that could be difficult, if not impossible, to implement using HTML and JavaScript. Galileo also allows developers to provide end-users with user interfaces that deliver the same rich experience as desktop applications.
Increased Productivity and Decreased Time to Market
Galileo's architecture has been designed specifically for developing browser-based,
rich internet applications. Its comprehensive control library and its easy and intuitive API
combine with all the benefits offered by the Java programming language to provide a drastic
increase in productivity over HTML/JavaScript application frameworks. Galileo allows developers to
create sophisticated RIAs in less time getting a better product to market faster.
Supports Standard Software Practices
Because the Galileo framework and the applications created with it
are client-based and implemented using a true object-oriented programming
language, developers can employ standard software practices such as layered architectures,
design patterns, and code reuse to improve the quality, maintainability
and extensibility of their applications.
Fosters Parallel Development
Galileo fosters parallel development and team synergy through its robust
object-oriented architecture. By promoting modular designs and loosely coupled
application components, Galileo makes it easy to develop and test UI components
independently and then effortlessly integrate them into the application when needed.
With little or no dependencies between individual UI components, individual developers
can work more efficiently thereby increasing the productivity of the project as a whole.
Reduced Server Load and Increased Client Responsiveness
Galileo applications are client-based which means that all UI processing is
handled by the end-user's machine not your web server. This benefits both
you and your end-users. It benefits you by freeing your web server from the
responsibility of processing requests due to UI interactions thereby reducing its
overall load. It benefits your end-users by providing them with a user-interface
that is richer, more efficient, and more responsive than the typical HTML-based web page.
Re-usable Skills and Negligible Learning Curve
With Galileo, developers do not have to invest a significant amount
of time learning niche and/or unmarketable skills in order to become
proficient with the framework. For developers already familiar with
Java, there is essentially no learning curve for Galileo. For developers with
little or no experience with the Java programming, the time invested to
learn Java will be time well spent adding a highly marketable asset to
their skillset.
Galileo applications have been tested and verified to look and behave identically on the
following browsers and platforms:
| Vista / XP | Linux | Mac OS-X | Solaris x86 |
|---|---|---|---|
| Firefox | Firefox | Firefox | Firefox |
| Explorer | Konqueror | Camino | SunOS Mozilla |
| Opera | Opera | Opera | |
| Safari | Safari | ||
| Chrome | |||
| Netscape | Netscape | Netscape |
Galileo development requires the following:
- A basic understanding of the Java programming language
- Java Platform Standard Edition
- The Galileo RIA Framework Development Kit
End-users must use a Java-capable web browser (e.g. Internet Explorer, Firefox, Safari, Chrome, Opera, Netscape, Camino, Konqueror) and must have the Java Runtime Environment (JRE 1.5 or higher) installed on their machine. In the event that the end-user does not have the required JRE installed they will be prompted to install the JRE plug-in before continuing. As a note, the Java Runtime Enviroment comes installed standard now on most new operating systems (Windows Vista, Mac OS-X, Solaris, and various Linux distros).