Collaborators: Stan Jarzabek (NUS); Brendan Mahony, Defence Science Technology Organization (DSTO), AUS; Leonid A. Kalinichenko, Moscow State University. RUS; Shaoying Liu, Hiroshima City University, JAP; Roger Duke, the University of Queensland, AUS

Because of this increase in complexity, the likelihood of subtle errors is much greater. Some of these errors may cause loss of money, time, or even human life. Formal methods (logic/mathematically-based specification/verification techniques and tools) have been established as the rigorous engineering methodology for the system development.

Many formal specification and design methods have tended to concentrate either on data modeling and algorithmic concerns (eg. Z, VDM, etc.) or
else on process control concerns (eg. CSP, CCS, etc.). Complex systems often have intricate system states and process control structures involving concurrency and real-time interactions. For instance, complex systems (such as integrated avionics systems, engine control software) can involve functional and timing requirements that must be eventually implemented as executing code on a communicating distributed topology. To formalise
such systems, it is necessary to have a language which is able to capture both the data/algorithmic issues and the process behaviour issues in a smoothly integrated, but also highly structured and modular, manner.

Our previous investigation has been focused on the syntax and semantic integration of Object-Z and Timed CSP called Timed Communicating Object Z (TCOZ) by Mahony and Dong. This research was supported by Australian Defence Science and Technology Organisation (DSTO) and Commonwealth Science and Industrial Research Organisation (CSIRO). TCOZ notation has been effectively applied to an aircraft Mission Computer (MC) Operational Flight Program (OFP). The success of this project was reported in the Australian national newspaper THE AUSTRALIAN on April 6th, 1998.

In order to develop TCOZ into a formal software engineering method, many important research issues need to be addressed. In this project, we will focus our research in the following areas:

* Extending TCOZ to model control systems.

* TCOZ approach to Component Based Software Engineering.

* Developing tools support for TCOZ.

XML: XML-based Variant Configuration Language

What is XVCL?

XVCL (XML-based Variant Configuration Language) is a meta-programming technique and tool that provides effective reuse mechanisms [2]. XVCL is open source software (http://fxvcl.sourceforge.net) developed at the National University of Singapore. Being a modern and versatile version of Bassett’s frames [1], a technology that has achieved substantial gains in industry, the underlying principles of XVCL have been thoroughly tested in practice. Unlike original frames, XVCL blends with contemporary programming paradigms and modern design techniques. XVCL uses “composition with adaptation” rules to generate custom artifacts (code, documents, models, etc.) from a compact base of generic, reusable meta-components. Because its simple rules are designed to enable effective reuse, XVCL can successfully manage a wide range of software variants.

Variants arise naturally – programs often must run on multiple platforms; customers typically need custom versions that evolve over time; software product lines encompass families of similar but distinct programs. Similar design and code patterns recur even within a single program. Because differences among such recurrences are usually subtle, they greatly complicate maintenance. The need to simplify how variability is handled motivated us to develop and use XVCL. XVCL provides general mechanisms for applying program variants to a common core of generic, adaptable meta-components. You can also use XVCL to manage variants in other product line assets such as software architecture, test cases, technical and user-level documentation and requirement specifications.

Using XVCL involves a methodology for creating solution structures for your application domain and for the types of variants you want to address. The XVCL processor automates the routine yet error-prone program construction tasks, allowing you to focus on what is novel about your problem domains, enhancing your creativity.

How does XVCL work?

XVCL works on the principle of adapting generic, reusable meta-components into specific components – for clarity, assume they are components of custom programs. Any location or structure in a meta-component can be a designated variation point, available for adaptation by ancestor meta-components. Program generation is 100% transparent to the programmer, who can fine-tune and re-generate code without losing prior customizations. Meta-components can evolve as needed without ever forcing retrofits.

You create meta-components by generalizing pieces of working programs, and/or by top-down domain analysis. From small number of meta-components, we can generate an unlimited number of different concrete components, classes or methods. A meta-component is an XML file containing code (written in any programming language), instrumented with XVCL commands for ease of change and evolution. XVCL commands, designed as XML tags, control meta-component composition and adaptation, select pre-defined, context-dependent options, and iterate meta-structures to generate fully customized programs. Meta-variables and expressions provide powerful parameterization mechanisms. Values of meta-variables are propagated across meta-components using scoping rules designed to enhance adaptive reuse in novel contexts.

You organize meta-components into a layered meta-component architecture called an x-framework. An x-framework is carefully designed into layers to enhance reuse. It is also “normalized” to eliminate redundancies. Meta-components at lower-levels are relatively context-free building blocks to be adapted for reuse by the higher-level meta-components. The topmost meta-component, called the specification frame, controls the whole composition and can tailor any detail in the x-framework. An x-framework forms a base of reusable assets, such as a product-line architecture, from which you build custom programs.

Starting with the specification frame, the XVCL processor traverses an x-framework, executing XVCL commands embedded in meta-components in order to produce custom programs (Figure 1).

Applications and benefits of XVCL

Applications include implementing product line architectures, design of compact, non-redundant, easy to maintain program specifications (generated programs are never edited), and managing variants in multiple versions of software documents and models. We envision many other applications in software and non-software domains.

It is well known that redundant code obstructs program understanding and maintenance. Yet, programs are often polluted by such code. We have completed 4 projects in which we studied redundancies in commercial software and applied XVCL to reduce program complexity by eliminating recurring design and code patterns. XVCL achieved code reductions of:

In other projects, we applied XVCL to design product line architectures for component-based systems written in Java, and using RMI, J2EE or CORBA for component communication. We designed Facility Reservation System (FRS) and Computer Aided Dispatch system (CAD) product line architectures [3,4]. Our FRSes were built as EJB™ components, organized into a 3-tier architecture. We used XVCL to create generic, reusable meta-components from which we could generate custom runtime EJB components that met functional variants for a specific FRS we wish to build.

CAD systems are used by police, fire and rescue and other similar organizations to dispatch resources (e.g., police cars) to handle incidents. CAD systems are distributed over the Internet, with components dedicated to different roles running on different computers. We addressed CAD variants related to functional requirements, component distribution, platforms and reliability. This project was funded by Singapore National Science and Technology Board and Canadian Ministry of Energy, Science and Technology, involving National University of Singapore, SES Systems Pte Ltd., University of Waterloo and Netron, Inc.

We also applied XVCL to manage variants in UML software models documenting FRS and CAD product lines [5]. In yet another project, we managed evolution of the City Guide System product line with XVCL.

XVCL is based on Bassett’s frame technology [1]. Frames have been applied in industry to manage variants and evolve multi-million-line, COBOL-based, information systems. While designing a frame architecture is not trivial, subsequent productivity gains and maintenance savings often repay the effort many times over. An independent analysis showed that frames can reduce large software project costs by over 84% and their times-to-market by 70%, when compared to industry norms (refer to QSM report in [1]). By reusing skillfully structured frame architectures, you need to focus on only the 5%-15% of a solution that is unique; the other 85%-95% is reused. These gains are due to the flexibility of the resulting architectures and their evolvability over time.

XVCL is extensible and, of course, free of COBOL heritage. We envision many software and non-software applications, as we can apply XVCL to any domain that can be represented as a collection of textual documents.

Reference:

[2] Wong, T.W., Jarzabek, S., Myat Swe, S., Shen, R. and Zhang, H.Y. “XML Implementation of Frame Processor,” ACM Symposium on Software Reusability, SSR’01, Toronto, Canada, May 2001, 164-172

In this experiment, we demonstrate XVCL's potential to reduce program complexity by eliminating redundant code. We also show how XVCL can be effectively applied on top of OO techniques, enhancing program maintainability and reusability.

Redundant code obstructs program understanding and contributes to high maintenance costs. While most experts agree on that, opinions on how serious the problem of redundancies really is and how to tackle it - differ. In this case study, we analyzed redundancies in the Java Buffer library, JDK 1.4.1, recently released by Sun. We found that at least 68% of code in the Buffer library is redundant in the sense that it recurs in many classes in the same or slightly modified form. We effectively eliminated that 68% of code at the meta-representation built with XVCL. If we take into account both executable code and comments, then we can eliminate 72% of code. Due to the smaller code base, lack of the redundant code and ability to trace the impact of changes, our XVCL solution scores higher than the Buffer library in terms of ease of maintenance. In this experiment, we designed our meta-representation so that we could produce buffer classes in exactly the same form as they appear in the original Buffer library. While we were tempted to re-design the buffer classes, we chose not to do so, to allow for seamless integration of the XVCL solution into contemporary programming methodologies and systems. This decision did not affect essential results reported in this study.

Defining redundancy: Code fragments that we studied typically contain definitions of classes, class attributes, constructors or methods. Redundancy occurs among similar code fragments. It is difficult to define redundancy in general and descriptive terms. Therefore, we shall accept the following pragmatic definition of redundancy for the purpose of this study: Redundancy occurs in a group of similar code fragments, whenever we can unify all the differences among those fragments at the meta-level, with the XVCL technique. We also require that the result is beneficial for maintenance, that is, such a unified meta-representation should be easier to understand and maintain than the original program with redundant code fragments.

Engineering variant requirements in component-based software product lines

Collaborators: Dong Jin Song (NUS), Paul Bassett (Netron, Inc., Toronto), Ajit Singh (University of Waterloo)

In this project, we attempt to define a scalable and extensible mechanism to handle variants, at both domain model and generic Product Line architecture levels. A suitable mechanism should allow one to structure domain engineering artifacts and precisely express variants. It will bridge a conceptual gap between a model of variants across Product Line members and customizations of a generic architecture that are needed to meet specific variants. This gap has negative impact on productivity of programmers during architecture-based system engineering. There is also a problem of how to keep the complexity of a generic architecture under control over many years of evolution. Without a solution to this problem, a generic Product Line architecture will not stand the test of time and the Product Line approach will fail to bring long term benefits.

In this project, we address the above mentioned open problems in the Product Line research. In particular:

We develop prototypes of generic Product Line architectures characterized by the following qualities:

We develop a construction environment for customizing and evolving generic Product Line architectures characterized by the following qualities:

Completed projects - descriptions:

Domain Engineering in Business Domains

Master students: Ong Wai Chun, Cheong Yu Chye (completed), Tian Zhongyi (completed)

In this project, we have been doing domain engineering studies in facility reservation and library system domains. Understanding and precisely modeling common and variant requirements is essential in building a generic Product Line architecture. At the beginning, we concentrated on domain modeling methods and developed novel methods for structuring domain descriptions and modeling variant requirements in a domain. In the later stage, we experimented with frame technology (by Netron, Inc., Toronto) to design a generic architecture for facility reservation system Product Line. In this project, we emphasized ease of customization and evolution of a generic architecture. These two requirements determine the success of the Product Line approach and are known to be difficult to achieve in practice. We built a Product Line construction environment comprising of domain model, Customization Decision Tree and frame processor to provide a descriptive and partially automated support for Product Lines.

Software Reuse Framework for Reliable Mission-Critical Systems (1999, on-going)

Project supported by Singapore-Ontario Joint Research Programme. Project partners include NUS, University of Waterloo, Singapore Engineering Software Ltd. and Netron, Inc, Toronto.

Principal Investigators: Stan Jarzabek and Dong Jin Song (NUS); Rudolph Seviora (University of Waterloo).

Collaborators: Paul Bassett (Netron, Inc.) and Ulf Pettersson (Singapore Engineering Software Ltd.). Master students: Wong Tak Wai.

In this project, we investigate methods for reuse-based development of reliable mission-critical software systems, with goals of increased software productivity and improved software reliability. To achieve these goals, we apply concepts and experiences of flexible software manufacturing to a selected class of mission-critical software systems. We work on method development together with Netron and apply methods at SES pilot projects. SES also provides expert knowledge of the mission-critical software system domain. We develop methods for building mission-critical applications more cost-effectively and also investigate how reuse technology can improve the system-wide qualities, such as performance and reliability.

We selected a command and control Computer Aided Dispatch system, CAD for short, as a pilot. CAD domain includes includes police, fire & rescue, health and port sub-domains. All CAD sub-domains are in a way similar - they include an operator receiving information about an incident, a resource (such as police force unit) assigned a task of handling an incident, issues of task reporting/monitoring, etc. However, there are also many differences across sub-domains (e.g., rules of how resource are assigned to tasks, monitoring, reporting and timing requirements, specific information to be stored, component deployment strategies, etc.). Based on specifications provided by our industrial partner SES, students at the University of Waterloo and NUS developed a prototype CAD system for police, as a distributed, component-based system. We further selected Task Management to experiment with modeling and implementation of a generic architecture for CAD Product Line.

Static program analysis and reverse engineering: methods and tools

Static Program Analyzers (SPA) are interactive tools that enhance program understanding by answering queries about programs. Query results display abstract program views that are easier to understand than program code itself. SPA tools save program maintenance costs, help in program conversions and re-engineering. In this project, we designed a program query language, PQL for short, to specify program queries and abstract program views. In PQL, we can query on global, system-level design as well as search for constrained code patterns. In the design of PQL, we identified query principles that are common to all source languages and separated them from language-specific aspects. Specifications of a source language parameterize otherwise language-independent PQL notation. This concept facilitates a table-driven implementation of the query resolution mechanism. Upon the program specification notation and PQL, we built a design framework for SPAs. Within the framework, we can study tool capabilities in the context of the underlying software maintenance process and programmer's behavior model. The framework facilitates systematic and cost-effective design of SPAs by generation of SPA components from specifications.

We have implemented SPA tools based on PQL for COBOL-85. We identified many difficult problems related to efficient query evaluation, solved only some of them, experiment with various media for storing program design information and extended PQL to allow for specification of program transformations.

The objective of reverse engineering is to extract design information from the program code. Reverse engineering can enhance program understanding during maintenance and is an essential phase of software re-engineering. Because there are many variations involved in reverse engineering projects (different languages sources, different reverse engineering heuristics), reverse engineering tools should be highly adaptable. We worked out a method for designing flexible (from the end- user point of view) and generic (from the tool designer point of view) reverse engineering tools. Our design method is based on conceptual modeling of tool capabilities and on separation of conceptual models from implementation-level considerations. Tools that we build can be customized to a reverse engineering task in hand, in particular, can work with different source languages, contain a user-level facility to specify reverse engineering heuristics and filters to tune in the reverse engineering process and can be ported across a range of physical program representations.

Strategic Re-engineering: Integrated evolution of business and software

Today, many companies report maintenance costs mounting to 80% of a total computing budget. The pace of program evolution appears to be much slower than the pace of changes in business. As the result, many of today's programs fall short of user expectations. Methods and tools are needed to better link software systems to business needs. We believe, successful solutions to software evolution problems require an integrated effort, covering business re-engineering methods and technical aspects of software evolution.

In this project, we developed a conceptual and methodological framework for dealing with business and software re-engineering in an integrated way. The framework is to help companies in planning business and software re-engineering projects. The framework defines blueprints for re-engineering scenarios. We formulated a methodology for business & software re-engineering, called strategic re-engineering. Strategic re-engineering starts by business analysis and re-engineering. After business phase, a combination of CASE-based new development and re-engineering of existing systems is used to support re-engineered business processes. Strategic re-engineering forms a generic framework based on which a company can define a re-engineering methodology customized to its specific needs.

The following were deliverables from this project: a methodological framework for business-software evolution, expertise in planning re-engineering projects in real-life situations and tool prototypes for analysis of business and software models.

Project execution and monitoring support tools

We designed process-driven project support tools. We are experimenting with both rigorous, semantically rich process models based on which we build highly specialized tools as well as with simple process models based on which we build generally useful project support functions. The challenge here is to define the process model that is flexible, can be customized to realities of a give software project and can evolve on the fly. We developed a prototype Project Execution Support System that guides software engineers in following a project plan, as defined by project managers. Based on the experiences with the prototype, we then developed WWW-based tools.

Other project management tool, called F-Metric, is meant for project managers to monitor the progress of the project, identify problem areas and modify the project plan (e.g., re-allocate resources, change project activities, etc.). Project monitoring is done based on the analysis of the project data collected by software developers and stored in the project database. We designed a conceptual level query language for project managers to help in analysis of project data.

There are many variations across software projects and our objective is to design generic cores for project support tools that can be customized to specifics of a software project in hand. Moreover, we want to reuse as much functionality as possible across tools and, finally, we want tools to share common project models and project data. We use domain engineering approach to design generic, customizable and integrated project support tools.

Support tools for business analysis and re-engineering

What do we need to know about the business in order to understand and, eventually, to improve business operations? Many business modeling methods have been described in the literature and applied in business re-engineering projects. We feel that current business modeling methods do not have a precise enough model of the underlying business knowledge. A model should be comprehensive enough to allow for a systematic study and precise formulation of re-engineering methods. It should also provide a framework for designing tools to support business re-engineering projects. We identify information requirements for business re-engineering based on the commonly used business re-engineering methods and case studies published in the literature. In this project, we formalize these requirements within the conceptual business model. Business models vary from a company to company and from one business re-engineering project to another. Therefore, we build a generic model first and then we customize the generic model to the needs of a given company and a re-engineering project in hand. We build the core of a tool environment for business re-engineering around the generic business model. We achieve a required level of tool flexibility by applying meta-CASE techniques. We derive the physical schema for tool repository and generate customized tools from the customized business model specifications. Tools built around our model can support business knowledge acquisition, business process modeling, performance/quality analysis and analysis of alternative business process re-engineering solutions.

Projects on formal methods:	Projects on software reuse:
Integrated Formal Methods	XVCL: XML-based Variant Configuration Language
Intelligent Electronic Referencer	Eliminating redundancies with XVCL
Object-Oriented Rule-based Software Engineering	Engineering Variant Requirements in Component-based Software Product Lines
Formal Design Techniques for Reactive Embedded Systems	Reliable Software Design and Development for Sensor Network Systems
Rigorous Design Methods and Tools for Intelligent Autonomous Multi-Agent Systems

Software Engineering Projects

On-going projects - descriptions:

Integrated formal methods