Building software from existing components, rather than always programming applications from scratch, is an approach to software development that we have been striving to accomplish almost since the inception of modern day computing in the early 50’s. Subroutine libraries, program generators and visual programming systems are three examples of software technologies that have been developed to address this problem.

Why build software from components? There are many reasons why this approach is desirable. For example, components have often been used in other systems and have been extensively tested; the design experience of experts can be captured in components; components can be sold as black boxes; and a lower level of software and programming expertise might be required to assemble components. Possibly with the correct choice of components, experts in specific application domains may be able to build application systems thereby eliminating one of the biggest sources of errors in software design and implementation, namely translating requirements into design.

What are the problems with creating software from components? Components are often dependent on a particular application domain, so identifying components is often difficult. Of course many general-purpose components, such as user interfaces, databases, and operating systems have been identified over the years and are in wide use. Identifying the component is not enough, we also need to create the structure to "glue" the components together. In addition, we need an approach to software design that assists in the identification of components and the underlying connection structure or "glue."

The advent of software technologies such as the World-Wide Web, SQL and multimedia databases, visual programming tools, Java, DDE, OLE, ActiveX and CORBA, have aided the development of component-based software. However, they have not solved the problem, even though these technologies have made some steps in component-based software design and implementation easier.

We are currently working on various component-based software systems at the University of Waterloo with the goals of understanding how to build applications from components, how to identify components, how to design the interconnection structure and how to minimize or even eliminate detailed programming. In addition, we are testing our theories on real application systems that have value in their right.

Frameworks that support the creation of component-based software have been developed for a number of different application domains. Examples include: software systems that allow access to, and presentation of, information related to maps without the limitations imposed by existing geographic information systems (GIS); a framework for the development of educational software systems called LiveBOOKs; and a framework for applications based on the World-Wide Web, and SQL and multimedia databases.

These frameworks are easy to use and enhance. Once the framework was identified and constructed, applications were implemented by undergraduate and high school students.

The research program is primarily based on the object-oriented paradigm, and has a simple goal, "learn how to build software from components and use the techniques in building working applications." There are a number of associated sub-goals:

• develop methods to identify and design reusable black-box components;
• develop methods to identify the underlying techniques used to "glue" components together;
• develop methods to map component-based software and its connection structure onto existing software structures;
• develop tools to support component-based software development;
• use existing components where feasible;
• and apply those methods and tools to construct working applications.

Design patterns describe how to assemble objects based on concepts such as separation of concerns. In effect, design patterns capture design experience "in-the-small." The viewpoint approach to software design helps the designer to isolate many design pattern constructs. In our research we have created languages for describing design patterns that allow the construction of tools so that we can apply patterns to objects to construct new objects with minimum effort.

Frameworks are semi-finished software architectures for a specific application domain, and they attempt to capture design experience "in-the-large." Frameworks represent the highest level of reusability currently found in software design and implementation. Design patterns and frameworks are related, in that design patterns are normally used to assemble components in a framework.

Most current frameworks are object-oriented and use techniques such as inheritance to convert them to a finished software system, thus requiring knowledge of source code. Our work focuses on dynamic adaptation of frameworks so that they can be used as black-boxes. This approach has implications for legacy code as it might be encapsulated and reused.

The viewpoint approach to design concentrates on the structure and functionality of the software system and not on the coding details. However, program details are critical for the appropriate operation of the system. We are continuing to develop transformations and supporting tools that map a viewpoint-based design into working code. The steps can be partially automated, in that the designer/programmer is allowed to intervene to decide on the specific transformation to be applied.

Many of the techniques that we are investigating can be described by using a process-language. Because the steps in applying a technique can be specified, the description can be used to design and implement tools. For example, the process of applying design patterns has been specified and used to describe a designer’s assistant.

In order to test our component-based methods and tools, we implemented a number of frameworks and applications, as well as a number of case studies. Some of the applications are used in production systems.

Since 80% of the data in the world can be geo-referenced, we decided to explore the use of maps as user interfaces. Information about objects on a map would be stored in the computer system in various files and databases. The data could be retrieved and used for presentation, or modeling and analysis, by selecting one or more objects displayed on the map.

We built a framework for the domain of map-based applications that would allow a variety of different data and associated processors to be used by simply selecting the map objects. The framework has been used in a number of real-world applications including support for the current study of the Toronto Waterfront, and cultural heritage system for a small community..

Technology-based education, where students interact with "live" content using computer software, is another area where a framework approach would be beneficial. Creators of educational materials need to concentrate on content and presentation and not "fight" with the technology to develop the final software product. We have created a framework called LiveBOOKs that is based on the LivePAGE multimedia database product. Several LiveBOOKs are currently being produced, including a series of 6 books for the Education Program for Software Professionals at the University of Waterloo. The framework is flexible enough to support the deployment of these educational materials on both the World-Wide Web and CD-ROM.

The World-Wide Web and the Internet provide an exciting platform for software application development and deployment. Databases and database tools, when coupled with Web browsers, provide a framework for the development of many common data processing systems. We have developed a framework approach and deployed several applications. These include the areas of accounts receivable, inventory management, space administration, human resources, and forms administration.

The process of applying software methods can be described in a process language, and this description allows us to develop interactive software tools to assist the software designer. We have developed a framework for the application of design patterns that allows the designer to choose the pattern and then the tool applies the pattern without error.

As an extension we are also examining transformation frameworks that support the development and application of transformations for the manipulation of designs and generation of code. More long-term goals are examining the use of these types of frameworks in reverse engineering.

Presenting the contents of a document using different media such as CD-ROM, the World-Wide Web and paper is becoming common. Different audiences often require abridged versions of the same document. Document engineering addresses the issues that are involved in the creation and presentation of such documents. We are currently formulating a model for describing documents as separate components or objects, and separating the content, structural, presentational and navigational information. The model will then be used as the basis of frameworks for document design.

A number of small case studies have been produced in order to investigate the effectiveness of our methods. We have designed an electronic mail system, analyzed the design of a syntax-driven editor through a reverse engineering process, and applied viewpoint techniques to legacy systems. The latter project gave strong indications of how we might treat legacy code as a black-box component.

The research team consists of two professors, three full-time research assistants, 2 undergraduate students on cooperative work terms, and 10 graduate students.

If you wish to discuss our research program further, please contact:

D.D. Cowan

Computer Systems Group

University of Waterloo

Waterloo, Ontario

CANADA N2L 3G1

Phone: 519-888-4690

FAX: 519-746-5422

Web: https://csg.uwaterloo.ca/