The work users do with an application can be divided into
actual work accomplished using the application and overhead
performed in order to use the application. The latter can be
further partitioned based on the time at which the work is
performed: before (application location and delivery), during
(installation) and after (upgrade) the installation of the
application. This category can be characterized as the software
deployment overhead. This thesis presents a component architecture
RADIUS (Rapid Application location, Delivery, Installation and
Upgrade System) in which applications can be built with no software
deployment overhead to the users. An application is deployed
automatically by simply giving the user a document produced by the
application. Furthermore, the facilities in RADIUS make the
applications self-upgrading. In the end, the users perform no
deployment overhead work at all.

The conventional way of using an application is to install the
application first, then start using documents of the application.
The object-oriented programming (OOP) paradigm suggests that this
order should be reversed: the data should lead to the code. However,
almost all software fails to meet this model of design at the
persistence level. While modern software often use OOP at the
program level, the underlying operating systems do not support OOP
at the document/file level. OOP languages use pointers to methods
to indicate what operations can be performed on the objects. We
extend the idea to include "pointers to applications". Each document
has an attached application pointer, which is read by RADIUS when
the document is opened. This application pointer is then used to
locate and deliver the application module necessary for the document.

RADIUS is designed to be compatible with existing technologies
and requires no extensions to either programming languages or
operating systems. It is orthogonal to programming tools, is
language-independent and compatible among operating systems, and
consequently does not impose limitations on which environments the
developers can use. We illustrate the implementations for the two
most popular platforms today - C++ on Windows, and Java. RADIUS is
also orthogonal to other component systems such as CORBA or COM and
is easy to integrate with them.