|
The name Appgen is a mnemonic for Application
Generator. The Appgen Development System is a
fourth-generation programming environment used by professional
programmers and developers, all over the world, to create
data-intensive client/server business applications in the
quickest most efficient manner.
 Employing
concepts of rapid prototyping, RAD (Rapid Application
Development), CASE (Computer Aided Software Engineering), and
OOD (Object Oriented Design), the Appgen 4GL provides a complete
environment for building applications from a cursory design spec
through documentation, final deployment, and implementation.
Software system implementation is not just the initial phase of
computer use, but rather is an ongoing process as users needs
grow and change continuously. Appgen, once again, provides
developers and support personnel with the tools required for
high-quality application maintenance and perpetual modification
and enhancement.
Many fourth-generation
development tools are actually code generators. Based on the
programmer's specified criteria, these tools generate generic
source code modules which must then be modified to meet the
needs of the expected application. This code must then be
compiled. Appgen is a set of already compiled, quality-assured
programs (Run Time) that perform all the basic operations of any
business application. Rather than modifying any massive code
module, Appgen developers define and build parameter files that
determine the exact behavior of the Run Time programs, thus
creating the unique processes of the applications.
Using a menu-based design
itself, Appgen leads programmers through the steps of
application design and development. A powerful visual interface
make it easy to build menus, file maintenance screens, data
entry screens, and selection screens for reports and other batch
processes. The visual interface of the Appgen Report Painter
allows you to build your reports directly on your screen,
regardless of the size of the printout.
|
|
|
Developing an application with Appgen is simple and
straightforward. After a cursory analysis, you begin
prototyping. From there, you just keep building on
top of the prototype until the project is completed,
regardless of any discoveries involving changes in
data structures. This is possible because of the
variable-length database which is tightly integrated
into development work done with Appgen. There is
never any need to predetermine and structure any
Appgen database with regards to the number of
tables, rows, or columns.
|
|
|
|
At the core of
Appgen is a Run Time engine that handles all the
basic functions of a business application:
menus, file maintenance and data entry screens,
reports, batch updates, and their corresponding
selection screens. These programs are already
compiled and only require developer defined
parameters to be complete and unique for each
task of a specific application. The compiled
programs ensure the best performance. The
parameters that determine the exact actions to
be taken by the engine are organized into files
which are referred to as the application
programs. These parameter files are reusable
objects that can easily be connected in a myriad
of ways to form truly user-friendly
low-maintenance applications.
|
|
|
|
The majority of
the coding is a matter of filling in blanks
which become the parameters of the program. Even
the coding of high level 4 GL functions and
macros is just the filling in of parameters that
are accessed at the different points of the
program's execution. Once the parameters are
complete, the programs may run - there is no
compiling of programs. The Development System is
the application that guides you through the
building of the parameter files.
|
|
|
|
Most of the
development and ongoing maintenance of an Appgen
application is accomplished with Appgen's
'visual interface'. This not only allows the
programmer to address the application from the
same perspective as the end-user, it also
provides higher productivity as the program code
is organized and accessed with a natural visual
interface rather than the traditional linear
program format.
|
|
|
|
All
Appgen development work is implemented on the
application server, providing centralized control
for system administrators and application
programmers. Applications developed with the Appgen
4GL automatically incorporate the more efficient
server-centric, thin client, model of client/server
computing. Client specific activities are also
programmed into the applications on the server side.
Whether the program needs concern the graphical look
of the application (e.g., colors, 3D windows,
message and text boxes, etc.) or the interface to
Windows-based applications, high level 4GL functions
of the Appgen Windows API's are supplied to
determine the way the application looks on the PC,
and to perform DDE calls to manipulate client-side
programs. High level functions also allow the
display of images and the playing of sound and video
files on the client PC, for fully-functional
multimedia extensions in the application
 |
On-line Help And
Documentation
|
|
Proper on-line
help and user reference manuals are the bane of
many development projects as the technical
personnel involved rarely have the time,
patience, and desire to create this necessary
element of any finished software system. The
Appgen Development System accomplishes this task
by catering to the way programmers work. As each
data field and process is created, the
programmer is prompted to enter some relevant
help text. At any point afterwards,
language-skilled personnel can edit this text in
a straightforward manner with little need to
consult the programmers. This help becomes
immediately available to users, on-line, at the
touch of a function key, or the click of an
icon. For the final touch, the Development
System provides a batch process that takes all
the help messages, and screen images, and
formats them in order, into a professional
product reference manual.
|
ODBC, Export/Import and the
Appgen Database
|
|
Transferring data from and to an Appgen database is
possible in several different ways. The easiest and
most popular method utilizes ODBC (Open Database
Connectivity). With Appgen, you may define any views
of the application data to allow your users to
easily transfer data between their Appgen
applications and current versions of almost all
popular desktop productivity products available
today, such as: Microsoft Office, Crystal Reports,
etc. The Development System also includes utilities
that will provide you the means to import ASCII data
into any Appgen database. An export utility allows
you to create ASCII output of any combinations of
data in Appgen files. |
|
|
|
The
Appgen database is an integral part of the Appgen
Run Time and the development process. It is a
variable-length relational database that allows
unlimited records, unlimited record size, unlimited
fields, unlimited field sizes, and one-to-many
relationships within data records. This powerful
database structure is supported by the Appgen ODBC
Driver that makes data trading with other
applications easy in a standard manner.
The
Appgen Database
Tightly Integrated, Variable-Length & Relational
Structure:
The
Appgen Database is a fully ODBC compliant hash-keyed
variable-length relational database. The variable
length feature provides for higher productivity in
software development, enhancement, and maintenance
by freeing the programmer from concerns about the
number of fields a file may contain, the size of any
field, the size of any record, or the size of any
file. All these constraints are handled
automatically by the database management system,
whether changes are made to data structures during
pure development stages, or during enhancements to
live systems.
The Appgen database also includes a powerful feature
not found in most of today's popular databases. This
feature, called the 'multi-valued attribute', allows
any data field to contain an indefinite number of
elements, or values. For example, a single sales
order data record may contain any number of line
items. This simplifies data structures and
eliminates a tremendous amount of programming time.
|
|
FOR
EXAMPLE:
In a typical database, information for a
single sales order is divided into many
records because of the database's
fixed-length record attribute:
|
 |
|
The programmer must maintain pointers to
all the records in the main header
record to tie all the related
information together. Sometimes, to
simplify the
process, the programmer utilizes
separate files for the three different
types of records.
|
|
 An
Appgen program, which utilizes the
Appgen database and its
variable-length feature, stores all
the information for a single sales
order in a single contiguous record.
The
database management routines
transparently handle all aspects of
dynamic record and field sizes. A
virtually unlimited number of line
items can be added to the sales
order record described above,
without the programmer having to
anticipate it.
ODBC (Open Database Connectivity)
In spite of its powerful
features that are not found in the
standard relational database model,
the Appgen ODBC Driver makes the
Appgen database look like any other
SQL database. With Appgen ODBC,
Windows-based applications can
access data in any Appgen data file
- and even write data to any Appgen
data file - using established and
standard methods. Appgen ODBC makes
the Appgen database truly 'open' to
the desktop computing world without
forsaking any of its unique and
inherent power.
Integrated
The Appgen database management
system is an integral part of the
Appgen Run Time and Development
System, and is not purchased
separately. |
|
|
|
|
|
The batch-update
(posting) engine ensures that you can design
your applications for professional operators
trained in rapid and voluminous data entry. The
batch entry and update once process eliminates
the need for time-consuming transaction
reversals as operators make errors in entry. The
built-in audit trail of the posting process is
transparent to both the user and the developer.
If the computer system should fail during a
posting process, the operator needs only to
start the posting over again, once the system is
operational again. The Appgen posting processes
knows exactly where it left off, and
automatically begins at that point with no
duplication of postings. From the programmer's
perspective, there is no coding necessary to
deploy this mechanism. From the user's
perspective, there is no need to do additional
backups before posting, and no need to restore,
roll back, or anything else to continue their
process.
|
|
