Model-driven development of large-scale Web applications

IBM Journal of Research and Development, Sep-Nov 2004 by Tai, H, Mitsui, K, Nerome, T, Abe, M, Et al

This paper describes our approach to support the development of large-scale Web applications. Large development efforts have to be divided into a number of smaller tasks of different kinds that can be performed by multiple developers. Once this process has taken place, it is important to manage the consistency among the artifacts in an efficient and systematic manner. Our model-driven approach makes this possible. In this paper, we discuss how a metamodel is used to describe part of the specification as a central contract among the developers. We also describe a tool that we implemented on the basis of the metamodel. The tool provides a variety of code generators and a mechanism for checking whether view artifacts, such as JavaServer Pages(TM), are compliant with the model. This feature helps developers manage the consistency between a view artifact and the related business logic-HyperText Transfer Protocol request handlers.

1. Introduction

As Web applications grow in size, the size of development projects grows as well, and it becomes more and more critical to support modular application design and parallel development. The challenge lies in meeting a few unique requirements. This paper describes our model-driven approach to support the development of large-scale Web applications.

The first requirement to be met is that the solution support the appropriate division of the development effort into smaller and different kinds of tasks that can be performed by various kinds of developers, such as architects, screen designers, and business logic programmers. It must then support the efficient integration of the many outputs from these different tasks. There must also be a cost-effective method of unit and integration testing if we are to maximize the parallel progress of the tasks that are inherently dependent upon one other.

The second requirement is to support the integration of different kinds of programming technologies, such as Hypertext Markup Language (HTML), JavaServer Pages** (JSP**), Struts, JavaBeans**, and possibly other in-house technologies designed to best suit developers' specific but differing needs. The methodology for Web application development is still in its early stages, and new technologies continue to emerge. Sometimes these technologies are alternatives, and sometimes they are used in combinations. In the latter case, the binding between artifacts based on different technologies is loose. For example, representing names as character strings is still a popular way to represent interfaces or references that cross technology boundaries. However, since there is no standard way to guarantee the consistency of such references, they are one of the parts of Web applications that typically cause interface mismatch errors and are very error-prone. Such errors are costly to detect and correct if this must be done manually. As the size of Web applications grows, automatic consistency checking becomes critical.

To meet such requirements, we designed a metamodel1 that describes the specification of a Web application, and we built a tool that utilizes the model (an instance of the metamodel). We use the specification description formalized by this metamodel as a central contract among all developers on a project. To check that all of the artifacts produced by the developers are in compliance with the given specification, we use an automatic stub2 code generation technique that performs the check in test runs. By checking this compliance, we can ensure consistency among different kinds of artifacts.

In an earlier paper [1], we discussed basic specification elements and associated support tools. This paper focuses on our model-driven solution, and we discuss in detail the effectiveness of the supported modeling elements and tools that were implemented to make use of the model description and facilitate Web application development efforts.

The paper is organized as follows. Section 2 discusses - the preceding work related to our metamodel and tool. Section 3 reviews modern Web application development technologies and practices, which follow a specific methodology and are based on one of the most widely adopted Web application architectures-the model-view-controller (MVC) pattern [2]. Section 4 describes problems associated with current Web application development practices. In Section 5, we propose a model-driven development method as a solution to the problems identified in Section 4. Section 6 describes the metamodel for Web applications, which is the basis of the model-driven development described in this paper. The prototype tool we built on the basis of the metamodel is introduced in Section 7, and Section 8 concludes the paper.

2. Related work

The Unified Modeling Language (UML) [3] notation is used to model the business logic and server objects in Web applications. A UML extension [4] is proposed for describing Web applications in which the relationship between a form and a Web page is represented by a submit association stereotype between the Form and Server Page stereotyped classes. In terms of the relationship between a form and a Web page, our metamodel is similar to this UML extension. However, the model elements in this UML extension are not related to the components in the MVC pattern. For example, both views and business logic in the MVC pattern are represented by Server Page elements. Thus, it is not straightforward to use this UML extension for modeling Web applications that are based on the MVC pattern.