The interface is the screen display that you use to interact
with
an application. You can use EGL to create different kinds of application
interfaces, including:
- JavaServer Faces (JSF) Web pages
- Javascript
Web pages
- Text-based console screens such as those on a mainframe
- Rich client displays that match the look and feel of the local
operating system
The type of EGL application that
you create is decided not by the
type of project that you create in the workbench, but by the type
of EGL artifacts that you use and the type of interface that you create
for the application. Whatever the type of the application, the EGL
projects, files, and code are organized in a similar way.
You
can create an application that has the characteristics of more
than one of these applications. For example, you might want to make
a Web site that uses logic or data from a service. The only restriction
is that not all application types can work together in the same EGL
program. For example, EGL Web pages use a specialized type of program
called a JSF handler (JSF refers to JavaServer Faces, a way
of building Web pages with reusable components), while Console UI
applications use a Console UI program. A single EGL program
cannot be both a JSF handler and a Console UI program. However, you
can have a Console UI program and a JSF handler in the same project.
If your EGL installation is configured to allow all of them, EGL
can create the following types of applications:
- Basic
application
- A basic application consists of one or more standalone
EGL programs.
Basic EGL applications provide batch processing or serve as the business
logic behind one or more EGL applications with interfaces.
- JSF Web application
- A JSF Web application
consists of one or more Web pages that are
controlled by EGL logic components. In most EGL Web applications,
these logic components are JSF handlers. You can
also use Web transactions, which are simple Web-based programs migrated
from VisualAge® Generator.
- Rich UI application
- A Rich UI application consists
of one or more Web pages that use
client-side JavaScript for increased flexibility and responsiveness.
- Text user interface application
(Text UI)
- A text UI application presents a text-based user
interface such
as that of a 5250 or 3270 terminal.
- Console user interface application (Console UI)
- A Console
UI application presents a text-based user interface
on a Java-controlled Windows® or UNIX® platform.
Console UI applications can also run in Rich Client Platform (RCP)
mode, which provides a graphical user interface like a Web application.
Instead of being rendered in a Web browser or as a text-based interface,
the rich client application uses the graphical interface features
of the user's desktop environment.
- Text user
interface applications and console user
interface applications appear to be similar but work in fundamentally
different ways. Both applications use a text-based interface called
a text form to display information to the user. The user types information
into the individual fields in this form and submits the form back
to the application. The application processes the information and
sends a new form to the user.
- However, the
applications manage the form in different
ways. A Text UI program waits until the user submits the form before
processing or validating the form.
- A Console UI program maintains
a constant connection to the displayed
form; it can process or validate the form whenever the user moves
from one field to another.
- Service-oriented
application
- A service-oriented application does not have its
own user interface.
Instead, each service in that application is designed to be invoked
by other code, including by other services. Like an EGL library, a
service includes a list of functions that requesters can access. Services
are stateless, which means that they treat each interaction
with a requester as new and unique. Every time a service runs, it
is as if it is running for the first time.
- Report
- A report application produces printed output, such as forms or
charts.
Regardless of the type of application
you work with, the structure
of the EGL projects, packages, and files in your workspace is essentially
the same: you write similar EGL code in similar EGL logic components.
From a programming standpoint, the major difference between these
types of applications is the type of interface that the application
uses.