Diefenbachg. 35, 1150 Vienna, Austria
bDistributed Systems Group,
Technical University of Vienna,
Argentinierstr. 8184/1, 1040 Vienna, Austria
Managing and maintaining such Web services becomes non-trivial when the size of the system exceeds a certain limit. Keeping the data organization, the information mapping to Web pages, and the navigation design manageable while providing a consistent interface in terms of layout and usability are basic requirements to successful Web services. From a software engineering perspective the Web is a new application domain. The lifecycle of WWW services [6,12] is comparable to standard software development and Web engineering tools have been developed in parallel to the Web services. A first generation of development tools concentrated on the creation of single pages for Web services. Examples for this systems are the HotMetal Editor  or Microsoft Frontpage . More advanced editors tried to integrate the development of a whole Web site, like NetObjects Fusion product . Those systems were restricted to passive hypertext presentation, supporting consistent layout across pages with only small support for the navigation model. Other tools concentrate on the semantics of the service, introducing support for multiple languages .
Some more advanced systems support the development of dynamic applications [2,3]. They provide the integration of reusable interaction components and the maintenance of state in session-oriented applications. Tools from the area of hypermedia design address a wider scope of the application lifecycle. The RMCase tool  employs strategies defined in the RMM methodology  to implement a hypertext system. To make use of this approach, the Web engineer must define the service in terms of entities and relations.
Currently the main research area for Web service engineers is the maintenance of WWW applications. A basic problem is caused by the nature of WWW servers that structure the information in file-based Web resources. The best design approaches are useless unless there is support for the mapping of the design step to the final implementation of the service. Recent engineering tools support the management of hypertext information on an abstract object-oriented level. The WebComposition system  tries to reuse components, e.g. design artifacts, on multiple pages and manage the service maintenance through handling abstract objects. The approach of dealing with objects to support highly manageable Web services can also be found in the W3Objects  system and HTML++ [1,13].
In order to provide Web engineering support for a complete Web site, further efforts have to be made. To cover both the lifecycle of the Web application and the integration of static information pages, multimedia data and interactive scripts, a system needs to be able to manage abstract objects of polymorphic types. We propose the JESSICA system, that describes components of a hypermedia system in an object-oriented language and provides a compiler to map the abstract system definition to highly dynamic Web services. The abstract modeling of the service supports the separation of layout and content information and the reuse of multiply used artifacts such as page designs for both static Web pages and dynamic script outputs. Web service maintenance is reduced to the manipulation of named objects with less size and supporting direct access to relevant content data compared to the final file-based Web service information. The expanding of the defined objects and the mapping to the Web server's repository is managed by the JESSICA compiler, the hypermedia publishing processor.
We will discuss the benefits of the JESSICA system showing a popular
case study. First we explain the object-oriented approach by describing
the syntax of the JESSICA language in Section 2. Section 3 discusses the
JESSICA system's implementation and its support for the lifecycle and flexibility
of Web applications. The system has been used to implement the Vienna International
Festival 1998 Web service (WFW). The strength of JESSICA
will be explained on the approaches and concepts implemented in the festival's
Web site in section 4. The final section describes the status of our work,
plans for future improvements and concluding remarks.
In Fig. 1 a simple example of a JESSICA Object is presented. Running the JESSICA Compiler on this example will generate the corresponding HTML page using the DST attribute to deduce the filename. An object can have several DST streams. Since there is no attribute DST given, the compiler will generate a unique name for this object.
Figure 2 shows a JESSICA Template with the variable title. The compiler keeps track on variable bindings in all objects and substitutes the defined values on object instantiation. One may even assign a default value to variables that are used unless the instance defines a content for it.
The sourcing (SRC) creates a new instantiation of the template CuteLayout. Afterwards HelloWorld has the same structure as the template, with the variable parts defined through the local object. This part can be addressed as HelloWorld.title.
The local object inside the package in Fig. 3 is anonymous (without a name defined), it only feeds a value via DST to the title component of HelloWorld. The example also shows, that nesting of objects is allowed in the JESSICA language. The package is necessary to avoid that the inner object is interpreted as content of the outer object. Actually, this provision of the value could have happened somewhere else as well.
Since templates in JESSICA are describing incomplete objects, the nesting of the latter provides instantiation of other templates. This nesting we call template inheritance, where a template is instantiated, but new variable parts are added. In this case, not all variable parts may be bound to values, thus the object compilation will result in another template. The template inheritance provides a clean subtyping concept for related objects.
One can specify several SRC attributes. In general, the compiler will try to match all streams against each other using a MIME sensitive pattern matching process. If the pattern does only match a substream, the match will be repeated to the rest of the stream segmenting it. This can be exploited for iteration over subobjects.
The prime use will be a match of a complete object against one (or more) incomplete objects (templates). With this mechanism existing objects can be restructured and matched components can be reused somewhere else for digests. Pattern matching honors optional, multiple and arbitrary attributes in objects while following on a longest-match first algorithm. There is also a notation for addressing bindings.
The MIME type is implicitly imported together with the object (as it is the case with HTTP). Or, one can explicitly specify a MIME type as in SRC="file(text/plain):somefile.txt". This MIME type and that of the environment controls the interpretation of the stream.
For portability reasons the language allows only 7-bit characters (us-ascii). Binary objects can be encoded arbitrarily but the conversion process has to be specified. If the object's MIME type does not match the SRC MIME type, an implicit conversion is necessary. By default the target MIME type is the same as the objects MIME type.
Figure 6 shows a global package for all objects in the JESSICA document (the local scope). Packages can be global, local, or local to another package. They may be named or anonymous.
Packages (containing their local objects) can be imported by specifying a SRC attribute. Package exporting is done by specifying a DST attribute. The generation of a perl package is done by DST="(application/x-perl-package) file: WF98.pl," triggering the currently defined embed process for the MIME type conversion.
When such a reference (see Fig. 7) has to be resolved within another object of type text/html, then an HTML anchor will be generated (<A HREF="index.html">here</A>). For other document types different behaviors can be defined using pragmas.
By default a pragma has global scope. Every pragma may also use a SCOPE
attribute to define to which object the pragma refers to.
The object-oriented JESSICA language provides a suitable abstraction for engineering large WWW sites. The implementation step of the WWW application's lifecycle is performed by the JESSICA compiler. The language, together with the compiler, builds the JESSICA System.
JESSICA uses compiler generators (JLex, JavaCup) to scan and parse the documents written in the JESSICA language. The compiler interprets packages and objects and tries to expand incomplete elements in order to create the corresponding output. The prime use of the JESSICA system is to manage large WWW sites. In such cases, objects describe documents and scripts on Web servers and their interrelations. Global packages are used to group objects to complete Web sites and ease their management.
References in objects may be expanded to HTML links. This feature provides a simple management of the hyperlink navigation model of a Web site, since relations within the Web site can be implemented using the abstract naming scheme of the JESSICA objects.
The Java prototype of the JESSICA compiler has mainly three tasks; reading
and parsing the source document encoded in the JESSICA language, retrieving
and expanding SRCes within the recognized objects and deparsing the generated
contents to the presented destinations. Thus, the architecture of the Java
system can be represented in the model shown in Fig. 8.
The compiler follows a fix point strategy in expanding incomplete objects until the list of incomplete objects is either empty or the object could not be resolved at all. Since incomplete objects can contain unretrieved objects in the SRC attribute, the expanding step may take several iterations until the DeParser can map the objects and packages to its file-based representation in the Web server's repository.
The data organization follows the entity-relationship approach, where all the information is structured in entities and their relations. JESSICA supports this approach in using abstract objects to define and describe the data for the hypermedia system. RMM's slice design to break up large entities into suitable objects for current hypermedia platforms is reflected in providing templates for WWW pages and script outputs. The navigation model is designed using the JESSICA object name space that is transferred to actual hyperlinks in the implementation step.
The actual implementation, i.e. the mapping of the abstract information description based on objects into file-based structures required by standard WWW servers is provided by the JESSICA compiler. Some quality assurance features allow the online checking of the navigation model (undefined links, unreachable documents) and the version management of the hypermedia application.
A very important point in engineering hypermedia systems is the maintenance of the services and applications. This major issue is often neglected in WWW service management and is very time and cost-intensive. The object-oriented approach adds a level of abstraction to the data management, thus allowing the service manager to work on named objects and identify data easier than in the final hypermedia system. The integration of external sources like database information, system call outputs and remote documents supports dynamic services on the WWW. Using the import feature properly combined with database controlled content management can add high flexibility to the hypermedia application . A case study, based on these properties is presented in Section 4.
An additional strength of the JESSICA system is the integration of static
hypermedia documents with dynamic (even interactive) server-side scripts.
Providing this combination, a Webmaster is able to manage his/her complete
site only by working on the abstract description level of the JESSICA language.
Basically this is possible through the handling of multiple MIME types
and the type conversion capability of the JESSICA compiler. This allows
the handling of both static information objects and dynamic scripting applications
as well as hypermedia contents in JESSICA objects. The compiler transfers
the polymorphic objects into the corresponding presentations on the Web
server, occasionally using some pragma directives. JESSICA objects may
have even multiple destination defined, which forces the compiler to create
multiple (polymorphic) copies of objects. These can be different representations
of the same content, based on the presented MIME-types.
In this section the special problems of dynamic services and the benefits gained from using a service like JESSICA shall be discussed. We will explain, how the abstract data management using objects and the importing of external structured information from databases are promoting the flexibility of the WFW application. It is not the purpose of this paper to list JESSICA code for the WFW. To stress the benefits of the JESSICA systems we discuss some approaches and concepts implemented in the case study.
Layout information defined as JESSICA templates can be reused for multiple content objects to have a similar appearance on the browser. In the WFW each performance of the festival was based on the same design layout reusing one JESSICA template. The separation also reduced the source code to one third of the final WWW document's size.
The separation strategy makes the WFW flexible to general application changes like the introduction of browser frames or sponsor logos. The integration of the new information into layout objects of the database changes any affected WWW document on the next JESSICA compiler run or database script access. Extensions of the existing service are handled through insertion of the JESSICA objects and templates. A single recompilation step transfers the updated objects into the desired service.
The abstraction of the data allows the reuse of snippets for Web documents of even different types. In the case of the WFW layout design, data from the database is used for both creating static HTML documents as well as for the appearance of server-generated script documents that show dynamic data or results of interactive queries.
The engineering system needs to support multilingual services and language specific static and dynamic services. Both the language-independent information like layout design and language-specific sections are stored in the WFW database. The abstract JESSICA objects guarantee a proper navigation model maintaining a pre-selected language track. Object References in JESSICA provide a simple modeling scheme for hyperlinks and allow easy maintenance of language tracks. The service engineer simply uses the language-dependent name of the related object in the REF tag to create the proper navigation model. The object-based approach to information management provides high flexibility to new language integration and language-specific data management. Information in further languages can be added without reorganization of the Web application.
The ticket reservation system is available on both standard HTTP server and a secure Web server to protect user data from eavesdropping. The usage of secure transmission guarantees privacy for specific user data. The state of the current ticket availability is triggered by the information manager of the Vienna International Festival. S/he changes the set of tickets manually via the access-restricted content management form. The application may deactivate the ticket reservation functionality on a temporal basis. An update-based rerun of the JESSICA compiler rebuilds the WFW to guarantee its high flexibility to dynamic data.
Currently we employ the JESSICA system on several Web servers to prove
its feasibility on mid-size and large Web applications. We have been engineering
the popular Vienna International Festival since 1995 and using
JESSICA to implement the recent version. Benefits in the administration
of Web sites as well as code reduction through reuse and the integrated
navigation management confirm the employment of JESSICA for engineering
such Web applications. For the acceptance of the system, which we plan
to open for the public, we are currently implementing an editor in JAVA.
The object-oriented approach will significantly benefit from an interface
that provides OO design facilities which we are currently investigating.
Comprehensive debugging information and the editor will improve JESSICA
to become a portable engineering environment for large Web services.
|||R. Barta, What the heck is HTML++, Technical Report TUV-1841-95-06, Technical University of Vienna, Distributed Systems Group, October 1995.|
|||A. Crespo and E. A. Bier, WebWriter: a browser-based editor for constructing Web applications, in: 5th International World Wide Web Conference, Paris, France, May 1996.|
|||The WebObjects HomePage, NeXT Software Inc., http://www.next.com/WebObjects/|
|||A. Diaz, T. Isakowitz, V. Maiorana, and G. Gilabert, RMC A tool to design Web applications, in: The World Wide Web Journal, 4th International World Wide Web Conference, December 1995.|
|||FrontPage Home Page, Microsoft Corp., http://www.microsoft.com/FrontPage/|
|||H.-W. Gellerson, R. Wicke, and M. Gaedke, WebComposition: an object-oriented support system for the Web engineering lifecycle, Computer Networks and ISDN Systems, 29(813): 142938, April 1997.|
|||D. Hillbrecht, MuLaW the Multi Language Web authoring System, http://www-c.informatik.uni-hannover.de/~dh/mulaw/, November 1997.|
|||The HotMetal HomePage, SoftQuad Inc., http://www.sq.com/|
|||D.B. Ingham, S.J. Caughey, and M. C.Little, Supporting highly manageable Web services, Computer Networks and ISDN Systems, 29(813):140516, April 1997.|
|||T. Isakowitz, E.A. Stohr, and P. Balasubramanian, RMM: a methodology for structured hypermedia design, Communications of the ACM, 38(8), August 1995.|
|||NetObjects Fusion Home Page, http://www.NetObjects.com/|
|||M. Schranz, Lifecycle of WWW services: an experience report, in: 9th International Conference on Software Engineering and Knowledge Engineering, Madrid, Spain, June 1997.|
|||M. Schranz, Engineering flexible World Wide Web services, in: Symposium on Applied Computing, Atlanta, Georgia, February 1998, to appear.|
|||The Vienna International Festival/Wiener Festwochen Homepage, http://www.festwochen.or.at/|
is currently preparing a PhD thesis on Web service engineering
at the Distributed Systems Group within the Information Systems Institute,
Vienna University of Technology (VUT). He obtained a MSc in Computer Science in 1994 and is currently affiliated
as research and teaching member with the Distributed Systems Group. His
general research interest is in distributed information systems engineering
and the World Wide Web.