Programming Language Design Research Articles

Strong typing of object-oriented languages revisited

This paper is concerned with the relation between subtyping and subclassing and their influence on programming language design. Traditionally subclassing as introduced by Simula has also been used for defining a hierarchical type system. The type system of a language can be characterized as strong or weak and the type checking mechanism as static or dynamic . Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several different solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.

MultiLogo: A Study of Children and Concurrent Programming

Abstract During the past decade, computer scientists have developed dozens of concurrent (or parallel) programming languages. These languages hold the promise of opening up exciting new applications for computers. But that will happen only if people can effectively learn, use, and understand these new languages. To explore these issues, I developed a concurrent extension to Logo (called Multi‐Logo), and conducted an experimental study with a group of elementary school students. The students used MultiLogo to control simple robotic devices built out of LEGO bricks. In analyzing the children's work, I developed three primary categories of MultiLogo programming bugs: problem‐decomposition bugs, synchronization bugs, and object‐oriented bugs. Based on the results, I recommend ways to improve the design and teaching of concurrent programming languages for nonexperts.

Design and code traceability using a PDL metrics tool

This article describes an analysis tool that extracts complexity metrics from program design language (PDL) as contained in design specification documents. The tool analyzes pseudocode and computes token-count metrics of PDL complexity on a module by module basis. We used the tool to measure consistency within and across modules and for assessing traceability between PDL and the corresponding source code. In applications of the tool, we were able to identify PDL descriptions that were too detailed, those lacking sufficient detail, identify inconsistent PDL descriptions, and measure traceability between the PDL description and the corresponding source code.

Strong typing of object-oriented languages revisited

This paper is concerned with the relation between <em>subtyping</em> and <em>subclassing</em> and their influence on programming language design. Traditionally subclassing as introduced by Simula has also been used for defining a hierarchical type system. The type system of a language can be characterized as <em>strong</em> or <em> weak</em> and the type checking mechanism as <em>static</em> or <em>dynamic</em>. Parameterized classes in combination with a hierarchical type-system is an example of a language construct that is known to create complicated type checking situations. In this paper these situations are analyzed and several different solutions are found. It is argued that an approach with a combination of static and dynamic type checking gives a reasonable balance also here. It is also concluded that this approach makes it possible to base the type system on the class/subclass mechanism.

Expert systems: principles and programming

From the Publisher: This new edition combines a thorough, balanced treatment of theory and practice with a complete package of CLIPS 6.0 software tools for developing expert systems. It features a balanced blend of expert systems theory and practice; a detailed presentation of CLIPS Version 6.0, a rule-based programming language for expert systems design; and an IBM PC 3 1/2'' disk which contains the complete CLIPS 6.0 executable shell and sample programs for developing expert systems.

Knowledge-based computer vision-integrated programming language and data management system design

Properties that are needed in a language for programming computer vision tasks are described, and a new object-oriented programming language and data management system approach is suggested. An example from automatic pose estimation is used to illustrate the necessity for the properties in a language system, it is indicated where other languages and data management systems fail to provide these properties, and the type constructors used in the authors' system and features of the language semantics of their system are discussed.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Type inference in the presence of type abstraction

A number of recent programming language designs incorporate a type checking system based on the Girard-Reynolds polymorphic λ-calculus. This allows the construction of general purpose, reusable software without sacrificing compile-time type checking. A major factor constraining the implementation of these languages is the difficulty of automatically inferring the lengthy type information that is otherwise required if full use is made of these languages. There is no known algorithm to solve any natural and fully general formulation of this “type inference” problem. One very reasonable formulation of the problem is known to be undecidable. Here we define a restricted version of the type inference problem and present an efficient algorithm for its solution. We argue that the restriction is sufficiently weak to be unobtrusive in practice.

Parsing tinyada in a programming language design course

Parsing tinyada in a programming language design course

Comparative programming languages

From the Publisher: This book identifies and explains the essential concepts underlying the design and use of programming languages and provides a good balance of theory and practice. The author compares how the major languages handle issues such as declarations, types, data abstraction, information hiding, modularity, and the support given to the development of reliable software systems. The emphasis is on the similarities, rather than the differences, between languages, and primarily covers modern, widely used objectoriented and procedural languages such as Java, C++, C, Pascal (including its implementation in Delphi), Ada 95, and Perl, with special chapters being devoted to functional and logic languages. The new edition has been brought fully up to date with new developments in the field: the increase in the use of OO languages as a programmer's first language; the growth in importance of graphical user interfaces (GUIs); and the widespread use of the Internet. This book is suitable for readers with a Java or procedurallanguage background who want to get into the theory of programminglanguage development and utilization. /*@ISBN = 0201710129 @MAINCAT = Programming Languages @DATALINE1 = 2001, 384 pages, 7 1/4 x 9 1/8 @DATALINE2 = Paper, $50.00k*/

Intelligent computer-aided instruction for the coding task

This paper describes an intelligent computer-aided instruction (ICAI) system for the task of translating a high level program design language (PDL) into a programming language. It enforces the desirable separation of algorithm design and coding by focusing on coding as an independent task. A production system formalism is used to represent the rules needed to do the translation. The intelligent tutor program presents a PDL program to the learner and then uses the production rules to translate it into FORTRAN 77, saving the correct set of rules needed. It then inputs the learner's translation, and when it is not correct, it attempts to determine those rules not applied correctly. After isolating an error, it is capable of several response levels which give the learner maximum opportunity to discover her his own error. These responses involve the generation of remedial PDL programs which highlight the rule that has presented difficulty to the learner. Finally, methods of incorporating the ICAI system into a beginning Computer Science course are presented.

A framework for teaching programming with reuse

A framework is proposed for introducing reusable programming as an engineering methodology in a typical programming class. The requirements of the teaching framework include a program design language, a code-frame-driven implementation strategy of the design and a presentation approach which is software-domain specific. Reusable design fragments are defined and tools are provided to assist students or users in the process of building reusable fragments and constructing composite program logics from existing fragments.

VMOE: A Virtual Machine Operating Environment for the Computer Systems Curriculum

A major challenge for computer science educators is to acquaint students with not only the properties of the major components of computer systems, but also with the interactions among these components. Real systems are too complex to serve as examples for these investigations and example systems which have been introduced in the past do not provide the flexibility to deal adequately with the component interactions. The Virtual Machine Operating Environment (VMOE) is an example system, comprised of a virtual hardware environment and a specially designed programming language, which provides a basis for environments in which students can investigate component interactions in a variety of courses. This environment can help focus the attention of faculty and students on the often neglected subject of component interactions.

Benign side effects

Many people interested in programming language design believe that functions should not have side effects. However, some side effects, such as incrementing a count of the number of calls on a function, are crucial for debugging and performance monitoring. Discussions of how to allow such benign side effects has foundered trying to find a suitable characterisation of ‘benign’. One possible solution is to associate more than one interface with a module and to say that a side effect is benign with respect to an interface if it is invisible if clients of a module limit themselves to that interface. We show how to use trace specifications to prove that a side effect is benign in this sense.

On the Complexity of Computing the Volume of a Polyhedron

We show that computing the volume of a polyhedron given either as a list of facets or as a list of vertices is as hard as computing the permanent of a matrix.

Parallel parsing in a multiprocessor environment

With the advent of multiprocessor systems the design of suitable programming languages and algorithms which exploit the paralelism provided by multiprocessor systems has become of great interest. However, the problem of designing and implementing parallel compilers has received little attention. This paper presents the method that we developed for distributing parsing on the set of communicating processes. Each process can run on one processor of a concrete multiprocessor system.

Contexts and metamessages in object-oriented database programming language design

VISION is an object-oriented database system currently used commercially to develop investment analysis and other large statistical applications. Characteristic of these applications, beside the standard issues of structural and computational richness, is the need to handle time, versions, and concurrency control in a manner that does not produce combinatoric complexity in object protocol. This paper describes the approach taken by VISION in addressing these issues.

A design tool used to quantitatively evaluate student projects

In the last decade, the field of Computer Science has undergone a revolution. It has started the move from a mysterious art form to a detailed science. The vehicle for this progress has been the rising popularity of the field of Software Engineering. This innovative area of computer science has brought about a number of changes in the way we think of, and work with, the development of software. Due to this renovation, a field that started with little or no design techniques and unstructured, unreliable software has progressed to a point where a plethora of techniques exist to improve the quality of a program design as well as that of the resultant software. The popularity of structured design and coding techniques prove that there is widespread belief that the overall product produced using these ideas is somehow better, and statistics seem to indicate that this belief is true. Until recently, however, there existed no technique for quantitatively showing one program better than its functional equivalent. In the past few years, the use of software quality metrics seems to indicate that such a comparison is not only possible, but is also valid. The advent of Software Engineering has demanded that most universities offer a Software Engineering course which entails a “Real-World” group project. Students participating in the class design a system using a program design language (PDL). Other students then write code from the design and finally the design team integrates the modules into a working system. For a complete description of the class see [HENS83] and [TOMJ87].

A group-theoretic approach to the computation of symbolic part relations

When a set of constraints is imposed on the degrees of freedom between several rigid bodies, finding the configuration or configurations that satisfy all these constraints is a matter of special interest. The problem is not new and has been discussed, not only in kinematics, but also more recently in the design of object-level robot programming languages. In this last domain, several languages have been developed, from different points of view, that are able to partially solve the problem. A more general method is derived than those previously proposed that were based on the symbolic manipulation of chains of matrix products, using the theory of continuous groups.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Issues in the design of object-oriented database programming languages

We see a trend toward extending object-oriented languages in the direction of databases, and, at the same time, toward extending database systems with object-oriented ideas. On the surface, these two activities seem to be moving in a consistent direction. However, at a deeper level, we see difficulties that may inhibit their ending up at the same point. We feel that many of these difficulties are a result of the underlying assumptions that are inherent in the fields of programming language and database systems research. Many of these assumptions are historical and contribute to a set of cultural biases that often prevent the two communities from interacting as effectively as possible. The purpose of this paper is to try to uncover some of the cultural presuppositions that have inhibited development of a fully integrated database programming language. We have identified database and language features that seem to be difficult to reconcile. We try to uncover the basic problems in these two areas that these features were intended to solve. In order to resolve these problems, we attempt to distinguish fundamental differences from historical artifacts.

Program design languages: How much detail should they include?

This experiment evaluated the effectiveness of using a program design language (PDL) specifically designed to aid in coding a corresponding programming language. PDLs were designed to reflect the constructs and level of detail of three particular programming languages (i.e. MACRO-11, FORTRAN and APL). We measured the performance of programmers coding from these various PDLs in MACRO-11 and FORTRAN. Each participant was presented with three programs in one of the two programming languages. Several lines had been deleted from each program. A participant's task, performed online, was to complete the code using the PDLs. For programmers coding in MACRO-11, the MACRO-like PDL was associated with the shortest coding times. Further, the participants said they found the MACRO-like PDL easiest to use, and they relied on it most heavily. For programmers coding in FORTRAN, the FORTRAN-like PDL was associated with the shortest coding times; the participants said they found the FORTRAN-like PDL easiest to use, and they relied on it most heavily. From these data we conclude that optimal use of a PDL requires that it be tailored to the target programming language in terms of type of construct and level of detail.