Nikola Serbedzija[HREF1], School of Computing Sciences, University of Technology, Sydney, PO Box 123 Broadway NSW 2007 nikola@socs.uts.edu.au
This paper discusses means and techniques for upgrading existing software systems to make them accessible for the Web users. The core of the Web-enabling problem is how to transform a sequential, single-user, machine-dependent software into potentially distributed, multi-user and cross-platform compatible one. Solutions should minimize the changes, maximize code re-use and may require redesign of existing systems, applying object-orientation and client/server paradigm. As a possible solution, a framework for enabling legacy systems called GoWeb is presented with its architecture and applications.
The Web technology is having major impact on the development and use of software systems. Most of the larger Web sites offer some kind of Web-based processing and new Web-based systems are being developed on a daily basis. Examples are: Web-enabled CORBA systems, large data-base systems and many new environments with active and mobile objects that can perform useful tasks for Web users. Web-enabled systems fulfill most of the key software engineering promises: they are widely available, cross-platform compatible, parallel and distributed, accessible to all kind of users: from mobile computers to powerful workstations in intranets, as well as in the Internet.
This paper deals with techniques and technologies needed to provide Web-based access to software systems. In particular, it focuses on techniques that can be used for renovation of legacy systems. Second section describes state-of-the-art of enabling technologies. Third section deals with re-design of legacy systems. Fourth section presents the GoWeb system - a practical example of Web-enabling middleware. Conclusion discusses achievements and open problems in the domain of Web-enabled systems.
The World Wide Web has become a universal platform for enabling remote access to both new and existing applications. Web browser, the client side program, has conquered a position of the most commonly used program today. Enriched with the Java Virtual Machine, a Web browser is de facto a standard front end, not only for hyper documents, but also for Web-enabled applications (Kouzes, R.T et al. 1996; Yourdon, E. 1996).
The basics of the World Wide Web technologies consist of a small number of relatively simple concepts:
Appearance of Java and inclusion of Java Virtual Machine (JVM) in Web browsers opened a whole range of possibilities to enrich Web-based processing (Hamilton, M.A. 1996). Small Java applications (applets) running within a browser's VMs may perform computations at a client side and start new processing using other communication protocols.
Figure 1 illustrates a general layout of a Web enabled system. On the left hand side a typical Web browser with HTML parser, FORM generator, JavaScript parser and Java Virtual Machine is presented. Its protocol engine supports HTTP and for advanced systems other protocols which at a lower level use TCP/IP. On the right hand side a typical HTTP server supporting CGI, JavaScripts, and Java programs is presented.
There are numerous techniques that can be used to interface exsiting software and make it Web-enabled. For the purpose of this work, three major approaches will be detailed: script based, Java based and midlleware based.
Script-based systems represent the first step towards Web enabling. The script model allows for integration of other programs into Web-based processing. The basic strategy is to configure a Web server to treat some HTTP requests as calls to external programs (in Figure 1 indicated as CGI/scripts).
form
processing and dynamic HTML presentations to more complex transaction
processing, e.g. flight-reservations, data-base retrieval etc. They can be
also used for user authorization and authentication, thus restricting
access to Web-enabled systems. Almost any existing program can be
invoked in such a way.This technique is the most commonly used in enabling legacy software for the use within WWW. Nevertheless, it has numerous limitations and is not sufficient for advanced systems.
Java-based systems represent further improvement in Web enabling. Java applets, attached to HTML documents may perform on-line processing at a client side and can also communicate with other server programs, using other protocols. The Java-based model has enriched Web processing with full programming capabilities (in Figure 1 indicated as Java and other programs).
Middleware-based systems are multi-tier client/server architectures that provide full distributed processing. In case of Web-enabled systems, a Web browser enriched with JVM plays a role of a universal front. At another end, various servers offer their services (like data-base access, the use of super-computers, or any kind of specific computation that can be invoked remotely). A complete infrastructure used to allow access, resolve remote method calls and bridge differences between different languages, protocols and architectures, relies in the middle tier.
This techniques is the most complex one, but offers full distributed and on-line capabilities in enabling legacy systems for the use within WWW.
Popular definition of legacy systems describes them as "large software systems that we do not know how to cope with but that are vital to our organization" (Nennett, K. 1995). In the time old systems were developed, concurrency and distribution were not well understood, efficiency was crucial, as well as memory saving. All that has resulted in usage of programming tricks and ad hoc methods which make maintenance very difficult, especially for very large programs. To make the problem even worse, both developers and software implementation techniques are not any more available in the organizations that use the systems.
Several principles have to be respected in renovating old systems: (1) the functionality should remain basically the same, while the form can be altered; (2) recycling should be maximized, i.e. re-use of the original system parts is preferred to simple replacement of old components with the new ones; (3) re-structuring of the system should preserve old solutions in a new software architecture.
With the use of Web and middleware technology any old, sequential, single-user piece of code can be brought to Web users. This means that old software:
The process of adaptation of legacy software for the use within the Web framework usually requires numerous stages. Firstly, an old application has to be thoroughly understood. Its structure and functionality has to be considered in order to determine the strategy for Web enabling. Secondly, a redesign of the system architecture has to be considered. Many modifications concerning distributed object-based processing may be required. Thirdly, the development of a new user interface has to be planned taking into account the system needs. Finally, the system composition of new and old software components has to be completed.
Understanding legacy application is the first and often the most difficult task. One of the most important criterion for Web enabling is to estimate whether the separation of user interface, data-base access and computation code is feasible.
Redesigning an old application is certainly the most complex task. Some systems can be renewed by simple redirection of the I/O. More often, the old code has to be decomposed into smaller functional entities. To provide object-oriented distributed composition, many old entities have to be wrapped into objects that can be further integrated with new system components. To provide easier coupling with other objects, each entity should have a clear interface. In this phase, a designer should decide which part of the system runs on server and which part on client side and how they are going to communicate.
User interface should be re-written in HTML or Java. This is a point where new functionality may be added to old systems. In the HTML version, the redesign is simple and straightforward and communication with the rest of the system is based on HTTP protocol. In the case of Java based user interface, the code can be either in a form of Java applet, if the system is to be used openly across the Internet or Java application (in case of more restricted access). The client/server communication can be implemented using any high-level protocol.
Embedding of renovated legacy application into the WWW framework environment depends on the techniques used and can be very simple in case of script-based systems, less simple in case of Java-based systems and quite complex in case of middleware-based systems.
Script based systems use CGI and HTTP protocol for Web enabling. If the legacy system works in a batch like regime (e.g.: (1) get the input (2) do processing (3) produce the output and exit), this is the most suitable technique. The necessary changes are the following:
This techniques is the most commonly used in practice. There are numerous examples on the Web. However, this approach suffers from the common shortcomings of the CGI technology.
Java based techniques should be used when a system being enabled contains a lot of interaction and on-line communication. However, rewriting of the user interface is only possible in legacy systems where I/O code is clearly separated from the rest of the code. The modifications required are:
This techniques allows for multiple use and on-line client/server communication and is much richer than the previous one. In the case that separation of I/O code is not possible or feasible, some other approach has to be taken (e.g. the development of Java-based I/O device emulations, etc.).
Middleware-based approach to legacy system enabling is a most complex one, but at the same time it opens numerous possibilities for the system enhancement. Not only can the system be brought to the Web, it can also be significantly upgraded and transformed into object-based, distributed and multi-user interactive system. The GoWeb system, is an example of middleware based approach.
All the three approaches mentioned above impose restrictions which make them more complementary than competing approaches. However, the middleware-based techniques are most general and may embrace other techniques.
The GoWeb system is an object-oriented distributed software
that gathers objects into a Web enabled application and can
be accessed from any platform that supports Java
(Serbedzija, N.B. 1999)
The GoWeb has been designed with the following objectives:
(1) to provide network computing by enriching Web sites with
software,
(2) to offer computing power to Web users by making a Web
browser the front-end of a powerful machine
connected to the Internet,
(3) to enable wide access to certain applications by enabling
publicly available software for the use within WWW and
(4) to revive legacy applications by re-programming their user
interface and providing Web access to legacy systems.
The GoWeb system changes the semantics of
the Web links: as HTML links text and pictures, the GoWeb
buttons link software objects, turning a "mouse click" into a "run"
command.
The GoWeb system has been designed and developed as: (1) heterogeneous cross-platform middleware - machine independent code, produced by Java interpreter, ensures the use of the system at any computer with JVM; (2) dynamic environment, configured in run time - the first service of a GoWeb server is creation of its own clients which allows the system growth according to the number of users; (3) extendible set of components that scales up without need for re-programming or re-start - the GoWeb administrator can add new objects to the GoWeb directory in run time; (4) robust system that tolerates component failures and never crashes - if some component fails, the GoWeb system reports the failure and continues with its service.
Underlying technology used to develop and implement the GoWeb system includes: (1) object-orientation -- the system consists of numerous objects that can be composed into a distributed application collaborating with remote method calls; (2) thin client principle -- the system favors small components at a client side with most of the processing done at the server side; (3) multithreading -- the system is inherently concurrent and has several control threads that handle multiple users and overlap communication with computation; (4) code portability -- the client side of the system consists of a set of Java applets which are downloaded to Web browsers. The GoWeb system is implemented in the Java programming language, using its advanced features for parallel and distributed programming.
Figure 2 presents the architecture of the GoWeb system. It is a three tier middleware, a distributed (client/server) software, placed between the existing computer resources and Web browsers. It is an infrastructure hidden from the user that resolves all the references and provides smooth collaboration of the GoWeb components.
Physically, the system components - a Web browser, a Web server, the GoWeb server and application servers - are distributed over several machines. Logically, the system contains four major parts: (1) portable code - a set of pre-programmed components which can be downloaded to an anonymous Web browser and play a role of the GoWeb front-end; (2) server code - with three main servers: directory manager, object composition manager, and session manager; (3) application interface - a set of procedures that provide communication and synchronization with Web-enabled application programs; (4) application programs - a set of the existing programs offered for the Internet use.
There are three application classes that can be currently enabled by the GoWeb system.
Existing applications are enabled by re-programming the user interface and by restructuring the system into: (1) client part, (2) application server part and (3) the GoWeb interface. The legacy applications and public domain systems (e.g. environmental simulations) are typical examples of this class of applications.
Computer resources are enabled by customizing session management and by adding software components needed for access and use of the resource being enabled. Examples are data-base access, access to super-computers etc.
New applications can be developed for the use within WWW. Such applications may be programmed in Java as a set of components configured with the GoWeb manager. The GoWeb kernel has been developed accordingly.
Figure 3 shows the typical control flow within the GoWeb
system.
Initially, the Web browser contacts the http server(1) and
downloads the initial applet(2). The applet then contacts
the directory of applications(3) and downloads a list of
applications(4). When the user chooses an application,
the initial applet contacts the
relevant application server(5) and downloads the new user interface
classes(6), using the custom class loader built for that purpose.
The new user interface is then started up and control passes to it.
The user interface contacts the application server and maintains
remote collaboration.
Web enabling with the Goweb system is illustrated with the transformation and use of the FAST simulation system (Serbedzija, N.B. 1997) FAST is a collection of simulation programs for modelling in an irrigation field, prediction of pollutant concentrations, modelling saltwater intrusion etc. The FAST system is a single-user system, written in FORTRAN, available only at the machine where it was developed.
To enable the FAST system for the WWW using the GoWeb framework, two major modifications have to be introduced: (1) development of collaborative simulation platform and (2) redesign of end-user interface. The first extension belongs to the server part of the system and includes wrapping the user interface calls with Java code. The second one requires re-programming of the GUI in form of Java applets. After these major changes are done, the enhanced system has to be embedded into the GoWeb framework.
The use of the GoWeb system and enabled FAST simulatior is illustrated with: (1) GoWeb user authentication and authorization, (2) FAST system embedding, (3) running the enabled FAST application.
When the GoWeb system is started, the first information a user gets is a short system introduction and a list of different user categories that may login (visiting user, registered user, intranet user and system administrator). Each user has to provide a login name and a password. After successful authentication, a web user receives the initial GoWeb applet that communicates with corresponding server (each type of user is allocated to different servers). In this way visiting users are completely separated from e.g. registered users. Each enabled application may have an additional list of authorized users (associated to specific application parts). Figure 4 contains a screen snapshot of the GoWeb initial applet.
The most generic function of the GoWeb system is system
administration. It has three built-in functions:
New, Edit and Remove
application. The administrator uses the New
command to add a new application into the system.
Adding an application is simple:
the administrator types in the name and
the description of the application, the application
host name and RMI server host name.
By pressing the ok button, the embedding of a new application
program is completed.
The Figure 5 contains a screen snapshot of the "system
administration window", illustrating the application enabling
(embedding of an application into the GoWeb framework).
Deploying an application within the GoWeb framework means running the specific interface within a Web browser. The rest of the functionality is a result of the collaboration between user applets and the application server. The Figure 6 contains a screen snapshot of the Web-enabled FAST simulation system.
According to the network computing principle based on a thin client
model, the GoWeb system poses minimal requirements to the users.
Web browser as a front end should have:
1. Java and JavaScript enabled
2. JVM that supports advanced Java features
The rest of the system remains at the server side and poses no
requirements to the users.
Of course, a user should know the URL of the GoWeb system
(Serbedzija, N.B. 2000).
Fast development of Web Technologies has extended the WWW capabilities with applications involving lightweight, client-driven functionality. In just a few years time, WWW has gone through a dramatic transition: from a medium for delivering content to passive clients to a medium for truly large-scale, global distributed computing. For developers, this opens opportunities to use new or legacy code and create a world-wide software pool, administered by multi-tier client-server middleware. For end-users, this means a possibility to access most of the systems via a single front-end: a Web browser.
This paper details three different approaches for legacy system enabling: script-based, java-based or middleware based techniques. The choice of the techniques depends on the legacy application itself and the specific requirements for its future use within WWW.
The major advantage of a script-based system is its simplicity. The client requirements are minimal, making this model attractive for a wide number of Web users. Development at a server side is clear and processing model is straightforward, reliable and efficient. Limitations are conceptual: it is a batch-like processing without on-line communication between clients and server. Correspondingly, script-based systems are optimal for small stateless transaction oriented processing.
With the Java-based enhancements a Web user always gets newly updated software version that runs on any platform. Another benefit is in relaxing server from processing carried at a client side. Though interfacing programs written in other languages may be difficult, the use of Java-based techniques is a very flaxible option for re-enginering legacy systems.
A middleware-based system that combines CORBA and Java appears to be an optimal solution for Web enabling. Due to its modular and object-oriented design, further extensions and modifications are easy. A major limitation of middleware-based approach is its complexity. The development of the middle tier is a tedious and error-prone task. Furthermore, this approach may embrace and combine the other approaches into a single enabling system. This was illustrated with the GoWeb system that apply all mention techniques in different subsystems. The experience gained with the GoWeb projects showed that once developed, such middleware can be re-used for different legacy systems offering a full transformation of a sequential software into multi-user and distributed one.
As Web technology evolves, new techniques are emerging providing for easier way for legacy system enhancement. One of these new arrivals is the XML language that opens new possibilities and is considered as a most promising enabling technique.
Kouzes, R.T et al. (1996). Collaboratories: Doing Science on the Internet, Computer, 29(8):40--46
Yourdon, E. (1996). Java, the Web, and Software Development, Computer 29(8):25--30.
Hamilton, M.A. (1996). Java and the Shift to Net-Centric Computing, Computer 29(8):31--39.
OMG (1995). The Common Object Request Broker: Architecture and Specification, (Object Management Group Inc., 2.0 ed.)
Nennett, K. (1995). Legacy Systems: Coping with Success. IEEE Software, January:(19--23).
Serbedzija, N.B. (1999) Web Computing Framework, Journal of System Sciences, 45(15), Aug.:(1293-1306).
Serbedzija, N.B. (2000). The GoWeb project [HREF2]
Serbedzija, N.B. (1997). Web-Collaboration Improves Environmental Simulations, Proc. Control'97, Cancun, May:(400-403).
Nikola Serbedzija, © 2000. The author assigns to Southern Cross University and other educational and non-profit institutions a non-exclusive licence to use this document for personal use and in courses of instruction provided that the article is used in full and this copyright statement is reproduced. The author also grants a non-exclusive licence to Southern Cross University to publish this document in full on the World Wide Web and on CD-ROM and in printed form with the conference papers and for the document to be published on mirrors on the World Wide Web.
[ Proceedings ]