Encapsulation constructs in systems programming languages

Reviewer: Allen Lewis Springer

This excellent paper examines certain encapsulation constructs of system programming languages which are essentially machine-independent languages. Thus languages like C and BLISS are excluded from discussion. Ada is the main language examined, and an extension of it is used for the examples. Other languages examined include Pascal Plus, Concurrent Pascal, Modula-2, MESA, and CLU. The paper asserts that two language constructs, Simula-like classes and Ada-like packages, are needed to support: (1) management of dynamically allocated resources, (2) establishment of reliable and secure interfaces, (3) sharing of resources at the user level, and (4) a high-level representation of the hardware environment. The paper describes the class and package constructs, and shows how neither can satisfactorily replace the other while still retaining efficiency, security, and several other needed properties. The main body of the paper is an outline of a “direct” implementation of a UNIX-style file system. The UNIX file system, and almost all others, are normally implemented indirectly. That is, files do not appear as separate data types, and system code is hidden behind hardware protection schemes where possible, in order to provide security. In a direct scheme, the file system would be simply another set of routines and data types are written in the same language that the user programs in. Security is provided by the language constructs. One advantage of a direct scheme is the efficiency of not needing to pass control through a state switching mechanism, which is common with hardware protection mechanisms. If extensions are implemented to system services when system modification is not allowed, the programmer may have only the “direct” technique available. Also, there are many areas besides file systems where the discussed encapsulation constructs are likely to be needed. A direct mechanism can be secure if all the languages and system facilities that the programmer can use enforce the security rules. This would be unrealistic in the usual general purpose operating systems, but could fit the single language “embedded systems” that Ada is aimed at. Although the direct implementation of a file system is an unusual choice for an operating system, it is still an excellent choice as an example because of its familiarity. The language issues are far larger than whether a file system should be implemented in a particular way. Many issues of language design are examined and the programming examples are extensive. The authors are to be commended for choosing a large and realistic example to demonstrate their judgements about language design. It is considerably more convincing than the usual paper with toy examples. Toy examples do not demonstrate sound technological design decisions well, since it is too easy for the reader to assume that differences of opinion are due to taste. This paper is highly recommended to anyone interested in the design of programming languages, and to those interested in the problems of writing systems in high-level languages.