Experiences with Architecture-Related Technologies

Automation

The automated production of software from very high level specification languages is one aspect of our architecture-based approach. The use of fourth generation languages and program generators has variously been credited with productivity improvements ranging from 10% to 5000%. We will assume that this wide range is attributable to differences in the baseline effort being measured against, i.e. the portion of the life cycle considered when computing the improvement factor. We assume that very high improvement factors (e.g. 50 times) are relative to the coding phase alone, while very low improvement factors (e.g. 0.1 times) are relative to the overall life cycle effort.

One rule of thumb that is sometimes used to estimate the benefits achieved by automatic code generation is that it takes about the same amount of effort to produce a given amount of specification text, regardless of the number of bytes of code ultimately produced from that specification. That is, it takes about the same amount of time to produce one line of assembly code as it does to produce one line of Ada or one line of ControlH. If 1 line of specification language translates into X lines of a current high-level programming language like C or Ada, then we estimate a factor of X improvement can be achieved in the coding phase (assuming no specification reuse). This turns out to be roughly consistent with the data and assumptions cited in the previous paragraph.

We have data from several demonstrations of our ControlH and MetaH languages and tools that suggest about 9 lines of Ada can be generated from each line of ControlH specification, and 18 lines of application code can be selected and integrated by 1 line of MetaH.

Reuse

Reported measurements of reuse usually apply to source code. A variety of figures have been reported ranging from 10% to over 90% reuse (Tracz , WISR) . High levels of source code reuse have been difficult to achieve without a viable technical approach for doing so, as well as some added effort and expense. However, within specific domains where such effort has been focused, reuse rates from 60% to over 90% are reported.

Our MetaH language and toolset supports the software and systems integration of application code modules obtained either by automatic generation or from a reuse library. MetaH provides coding guidelines that facilitate the automatic integration of source modules from a reuse library. In our reengineering experiments, about 5% of existing application code needed to be modified or extended to allow software and systems integration using the MetaH language and toolset.

Distinguishing Features of the Architectural Approach

Reusing Architectures

An important aspect of the architectural approach is the reuse of design or architecture specifications. Architecture-based development is a specific technical approach to achieve increased design as well as increased source code reuse. We will assume the achievable architecture specification reuse within a domain is comparable to the reported 60-90% for source code reuse within a domain. We will attribute savings due to architecture reuse to the design rather than the coding phase.

Blending Automatic Generation with Reuse

Architecture specification languages and tools operate primarily by composing existing source modules rather than automatically producing code from scratch. The architectural approach blends automatic code production with source module reuse. The internal functionality and design of an individual source module is not completely dictated by the tools. The languages and tools need not be so highly tailored or restrictive as to be useful for only a very narrow type of functionality.

We will make the conservative assumption that the reductions in effort due to automation and reuse are not multiplicative, but that the main benefit of combining both is a greatly extended range of applicability of architectural methods and tools. We do not assume that combining automation and reuse result in productivity gains by a factor of 20 to 100, for example. However, we do assume that the effort can be reduced by a factor of 2 to 10 in multiple phases of the life cycle, where some tasks are more amenable to reuse and some to automation. The combination also makes the approach applicable to a reasonably broad range of software products.

Eliminating Rework

Another important aspect of our work is the integration of various analysis tools with the code assembly tools. A common architecture specification is used both for analysis and code assembly, which increases significantly the precision with which the analytic results predict the behavior of the implementation. The ability to analyze a specification, particularly to obtain approximate analysis results from an incomplete specification, can significantly decrease the amount of rework needed.

The common procurement cycle of exploratory development, advanced development and engineering development incorporates some redundancy. In the area of GN&C software, it is common for models and algorithms to be reimplemented numerous times as development progresses from systems engineering through software implementation to test and V&V. Of the 70% of the life cycle cost that occurs following deployment, the majority is devoted to product upgrades and enhancements rather than defect removal. The DoD Software Technology Strategy report indicates rework avoidance may produce a 37 to 50% reduction in overall software effort. We will approximate this as a factor of 2 reduction in overall life cycle effort due to work aviodance, recalling that much of our rework avoidance transcends the software development process.

Applying a factor of improvement of 2 to all life cycle phases due to the elimination of rework, then an additional factor of improvement of 2 to 10 to the 80-90% of the life cycle that automation and reuse can be applied to, yields an estimated overall factor of improvement of about 3 to 10.