Environmental acquisition revisited

Reviewer: Markus Wolf

The design of a programming language is a difficult business. On one hand, it has to follow the design ideas of its main paradigm, and be a tool for solving all kinds of problems suited to that paradigm. On the other hand, there are classes of recurring designs that cry out for special language constructs to deal with them more elegantly. This paper describes one instance of such a special class of designs, and how to extend Java-like languages to deal with it. Most object-oriented developers have encountered these designs, especially in graphical user interface (GUI) programming; one instance is known to the pattern community as the composite pattern. In order to handle such hierarchically composed structures, a lot of infrastructure code has to be programmed (always an error-prone business) to keep the structure consistent, and to fetch and set properties from somewhere down the containment hierarchy. The developer would rather express the relationship more directly in the programming language, so that the objects just acquire the needed properties from their hierarchical environment. This is where this paper starts. In the first section, the problem is defined and explained, and a short overview of early, informal, and experimental approaches to extending programming languages with constructs for environmental acquisition is presented. The second section presents some motivating examples, most of which are probably well known to the experienced object-oriented developer. The next section very briefly introduces the ClassicJava formal model for Java-like languages. The main section of the paper follows, and provides an introduction to Jacques, an extension of the ClassicJava model that supports the environmental acquisition of fields and methods. This section describes the syntax of the extension, the modifications needed in the type system, and the semantics of the language, and presents some sketches of a type soundness proof for the model. The fifth section discusses the design of Jacques, and explains why certain alternatives were chosen. Here, the authors clearly show which design decision was unavoidable, and which is open to discussion. They are well aware that only a future implementation, and some experiences with real-life programs, will decide some of the options. The last sections discuss how the model can be scaled to a full implementation in Java, cite some related work, and indicate what still has to be investigated before adding environmental acquisition to a real implementation of a programming language. This paper is very useful and understandable. Whether you are a developer who is interested in future design ideas in programming languages, or a real language designer on the hunt for new ideas, you will find something useful and interesting in this short paper. I hope that some of the ideas will find their way into the Java language sooner or later.