Yoix / YWAIT, the Yoix Web Application Instant Template
YWAIT provides a substantial and expandable framework for the server
side of a Web based application that uses Perl for cgi scripts and
relies on Java and the Yoix interpreter to provide the client side
We've used variations of this architecture, which we described
in a 2002 paper,
to build large web based production systems and we've done it for many
Even though we've made many changes in this version you can
still expect reliable, flexible, production quality behavior from the
YWAIT client and server software.
What it is
The source package includes everything you need to build and install
the server software on systems that are equipped with standard Unix
and Java development tools and run a web server, like Apache.
also builds an installer for the client-side software as well as the HTML
document that is displayed when you point a browser at the application web site to
provide a link to that installer.
The client software is the Yoix
interpreter, possibly augmented by custom modules, in an executable
jar file that starts the interpreter using a very small application
specific class that knows how to get to your web site.
the installer once and then rely on the server to keep everything,
including the jar file installed on their system, up to date.
We've used variations of this architecture since 1998 and we think
of it as a Web Application, but you may prefer to call it a Java
Application, a Rich Internet Application or something else
architecture and we don't rely on HTML or XML.
Instead, Java takes
the place of the browser and we use the Yoix interpreter, which is
written in Java, for scripting and providing a platform independent
interface to Java.
The format of the data exchanged between a client
and the server is not specified. Instead, the Yoix script that builds
the screen used to present the data and the cgi script that delivers
data to that screen make the decision, and they can pick any format
they want, including HTML or XML.
This architecture and our desire to use it and Java to deliver real
production applications inside AT&T is why Yoix was written and why
platform independence was and still is a primary focus of the Yoix
A single (rather large) Java application, namely the
Yoix interpreter, concentrates really hard on tricky Java issues
and also happens to accept a reasonably simple scripting language.
By placing the Yoix interpreter between the Java Virtual Machine running on
a client and Yoix scripts sitting on a server, you'll most likely
end up with a portable application.
an advantage even when you don't - one Java program means one place
to address portability issues, and when it's done right Yoix scripts
So it's the Yoix scripts sitting on the server that are endowed with
the coveted Write Once, Run Anywhere property and it's the Yoix interpreter
that we change when portability issues arise.
The interpreter lets us
reuse our Java code while the language, which intentionally omits a way
to access arbitrary Java features, limits Yoix scripts to the features
that are exposed by the Yoix interpreter.
An obvious downside is that
the Yoix interpreter always lags Java, but the same thing undoubtedly
can be said about any substantial Java application.
Java's latest and
greatest features usually take time to appear in production programs,
and that's really the way it should be.
With the Yoix scripts residing on the server,
application maintenance and updating are easy.
Just change or add new script files on the server and they are automatically distributed to the clients as with
any web documents.
Also, since the server-side is just the familiar web server model, setting up the application's back-end requires
no new skill sets.
For example, databases can be accessed using typical perl/odbc methods and the data can be transferred to the
client GUI using any number of suitable approaches as mentioned above.
What you get
YWAIT is the complete source - from makefiles to application installer - for a fully functional
Yoix web application framework.
With YWAIT, you can focus your resources on writing your application specific code and not worry about all the
tedious boilerplate required for a complete, production-quality application since YWAIT gives you that part.
The YWAIT framework delivers a functioning generic stub application out-of-the-box that includes:
make files (a standard make program such as the freely available
GNU make is required to process the make files);
instructions and usage examples;
administrative features, such as:
adjustable shut-out settings (block all users, block non-administrative users, etc.);
automatic update of the Yoix interpreter and extension modules based on release number;
password access control;
inactivity detection / log-off;
multiple system instantiation capability (prototype, development, demonstration and production);
a client application installer (installs the Yoix interpreter on the client machine);
and much more.
After downloading the YWAIT package from our download page, look at the
top-level README file to see how to configure the application for your environemnt. Configuration is
pretty easy and involves supplying basic information like the name of your application, where it is to be
installed, the URL to reference it, and so on. You will, of course, also need to configure your web server
appropriately in the same way you would for any web site consisting of document files and CGI scripts.
As always, contact us if you have questions.
Yoix is a registered trademark of AT&T Inc.