CLUs about Ada

0. The Two Questions

1) Was the Ada design effort an unnecessary government waste of taxpayer money which could have been saved if they considered CLU?

2) Or did Ada satisfy the DOD's requirements better than CLU?

1. What If CLU Was Evaluated?

I would bet that the DoD had felt very pity that they missed CLU for evaluation. It was surprising that these two languages were designed for almost the same goals without referring to each other. Some of their main goals are:

1.1 Reliability and Safety
Ada is a programming language designed to support the construction of long-lived, highly reliable software systems. CLU was also used mainly for large software systems. They were both designed to avoid error prone features and to maximize automatic detection of programming errors. Ada and CLU both requires separate specifications for all modules other than stand-alone subprograms which facilitates incremental or separate compilation. In order to detect error as early as possible, strong type checking was included in the design of both languages. They preferred compile time checking to runtime checking in order to find errors early. Ada used name equality only and avoid structure equality for the sake of simplicity, while CLU used both name and structure equality with more emphasis on safety.

1.2 Readability and Maintainability
Ada was originally designed with readability in mind, so was CLU. Not like C++ and Java, which include a great deal of terse notation which reduces readability (e.g. Is ++(A[i++]--)+=1 understandable?), Ada and CLU are neat and elegant. They were geared toward developing production code and encourage user documentation of programs, which are also helpful for building big, reliable systems.

1.3 Efficiency and Performance
Features were chosen to have a simple and efficient implementation to avoid execution costs for available generality where it is not needed. Compile time checking was preferred to run-time checking because it enabled better runtime performance as well as safety. Simple is fast, so Ada and CLU both aimed at a simple language not only to improve performance but also reliability.

1.4 Data Abstraction
In fact, we can say most of the similarities between Ada and CLU are originated from their implementations of data abstraction. It is data abstraction make it possible that these two languages can achieve their design goals.

CLU is the first language which achieved data abstraction. A data abstraction, or abstract data type, is a set of objects and operations. Programs that access the objects can do so only by calling he operations, which provide means to observe an object's state and to modify it.[2] Programs are developed incrementally, one abstraction at a time. Further, a distinction is made between an abstraction and its implementation.[3] Similarly Ada achieved data abstraction with private data types and representation specifications which separate the abstract properties of data from its physical realization.

Data abstraction simplifies the relations between modules, thus increases the programs simplicity and readability. Separating the abstraction and implementation is essential to reliable programming designing. With data abstraction, CLU is like Ada in spirit.

2. We Would Still Have Ada

Of the 113 requirements set forth in the STEELMAN[4], Wheeler found that Ada95 meets 94 while only failing 3. Ada83, a subset of Ada95, complied more fully with the STEELMAN and only failed to meet 2 requirements: 3-3F, 10F. Requirement 3-3F requires a specific syntax for constants and functions that Ada does not support. Requirement 10F requires simple assertion capabilities. Run-time assertions can be trivially implemented in Ada, but Ada does not provide a built-in construct for them. I don't know how many requirements will CLU meet. As least, CLU also fails to meet these two requirements. When designing CLU, the designers did have kept in mind run time checking for some variable initialization where compiler time analysis is inconclusive. However, due to lack of manpower, this feature was not implemented, so CLU has no assertion capability either.

Before Ada was invented, data processing and scientific programming were catered for by the standard languages COBOL and FORTRAN respectively, while the scene for embedded systems was confused. Therefore, Ada was designed with the goal of establishing a single high order computer programming language appropriate for DoD embedded computer systems. It was designed as a practical language and specially for embedded systems, while CLU is not designed for practical use nor educational use. The main goal of the work on CLU was to contribute to research in programming methodology. The designers hoped to influence others through the export of ideas rather than by producing a widely used tool. This difference in design goal made CLU less powerful than Ada, but simpler, thus can not meet the STEELMAN better than Ada,  nor can take the place of Ada.

Generality[1] is the first one of the eight general requirements of DoD. It requires the language shall provide generality to satisfy the needs of embedded computer applications. Such applications involve real time control, self diagnostics, input/output to nonstandard peripheral devices, parallel processing, numeric computation, and file processing. CLU emphasized on conveying new ideas, thus didn't implement many systemical features nor low level features. For examples, CLU does not have parallel processing, and can not handle concurrence; CLU was not oriented towards low-level system programming, thus can not directly control hardware; CLU's ability of input/output is limited, which limits the kinds and number of peripheral devices it can handle.

Machine independence[1] is another one of the eight general requirements of DoD. Ada did not dictate the characteristics of object machines or operating systems except to the extent that such characteristics are implied by the semantics of control structures and built-in operations. It avoided features whose semantics depend on characteristics of the object machine and of the object machine operating system. While CLU's compiler emphasized performance over portability, and the compiler is difficult to port to new machines. (Efforts were taken later to make portable CLU compilers)

CLU addressed the many important issues addressed by Ada. I believe that if CLU were included in the set of programming languages evaluated, the evaluation would have gone from STRAWMAN directly to STEELMAN, and cost much less taxpayer money and time. Also we know that CLU does fall to meet some important requirements, even though it does meet many of them, so CLU is not able to replace Ada without many chagnes. Therefore, I perfer to redesign a new language strictly following the requirement. That is why I believe that we would still have Ada, not CLU79.

Would Ada be better than it is, if we start from CLU, not Pascal? Maybe. Huh, who know.

References

Reviewers

List everyone you discussed this assignment with, and describe their contributions. The ideas and writing must be your own.

University of Virginia CS 655: Programming Languages

pl9a@cs.virginia.edu Last modified: Tue. Jan 18 11:10:50 2000