Review from Brian de Alwis

Problem

This paper describes the AHEAD model for synthesizing software systems through the piecewise composition of program features, and an overview of the implementation of a set of tools supporting development using AHEAD.

The AHEAD model describes programs using a containment hierarchy and refinements as functions that transform these hierarchies. Its use of a composition algebra enables automation of step-wise refinement. These refinements are viewed as functions that produce a feature-augmented program as a result. A program is then a composition of some features to some program. The system uses a carefully defined form of composition. A composition operator must be defined for the different types of elements (e.g., Java files, XML files, etc.). Composition is only applied to base level artefacts -- others are then regenerated from these artefacts.

Contributions

• Broadens MDSOC ideas to include non-source code files.
• Defines a model of program generation through hierarchical refinement, and provides a composition algebra with defined semantics.
• Describes an automated system implementing this refinement process.

Weaknesses

• Despite the initial focus on product lines (``focus has been on the production of source code for individual program.s This is too limited.'' p187), their examples do not appear to be product lines.
• Fails to address the use of layers for the shared layers of the AHEAD tools (p.194), instead of implementing them as a library.
• It would be more encouraging to see assessments of systems either maintained or developed by others.

Questions

• Development using AHEAD seems to produce a huge number of layers (21 for the STRICOM, 69 for the AHEAD tools).
  • Does this extensive (excessive?) layering pose comprehension problems for developers?
  • Are all programs able to be shoe-horned into a hierarchical structure?

• What are the impact on development? Does product-line development suffer from fragile-superclass issues?

• Refinement seems to assume that the composition of two things of equivalent type results in a third thing of equivalent type. Are there situations where this merging actually produces something of a different type?

• Subject-OP and Hyper/J maintained the need for different types of ``glue'' / composition rules. Is AHEAD able to cope with just composition because of its strict hierarchical composition?

Belief

• I believe this is an interesting work. I'd appreciate more discussion in comparing and contrasting the different models of program refinement.