Showing papers in "Sigplan Notices in 1989"

A laboratory for teaching object oriented thinking

Abstract: It is difficult to introduce both novice and experienced procedural programmers to the anthropomorphic perspective necessary for object-oriented design. We introduce CRC cards, which characterize o...

The syntax definition formalism SDF—reference manual—

Abstract: SDF is a formalism for the definition of syntax which is comparable to BNF in some respects, but has a wider scope in that it also covers the definition of lexical and abstract syntax. Its design and implementation are tailored towards the language designer who wants to develop new languages as well as implement existing ones in a highly interactive manner. It emphasizes compactness of syntax definitions by offering (a) a standard interface between lexical and context-free syntax; (b) a standard correspondence between context-free and abstract syntax; (c) powerful disambiguation and list constructs; and (d) an efficient incremental implementation which accepts arbitrary context-free syntax definitions. SDF can be combined with a variety of programming and specification languages. In this way these obtain fully general user-definable syntax.

Customization: optimizing compiler technology for SELF, a dynamically-typed object-oriented programming language

Abstract: Dynamically-typed object-oriented languages please programmers, but their lack of static type information penalizes performance. Our new implementation techniques extract static type information fr...

An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes

Abstract: We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our SELF implementation runs twice as fast as the fastest Smalltalk implemen...

Software metrics: using measurement theory to describe the properties and scales of static software complexity metrics

Abstract: Over the last decade many software metrics have been introduced by researchers and many software tools have been developed using software metrics to measure the "quality" of programs. These metrics for measuring productivity, reliability, maintainability, and complexity, for example, are vital to software development planning and management. In this paper a new approach is presented to describe the properties of the software metrics and their scales using measurement theory. Methods are shown to describe a software complexity metric as an ordinal, an interval or a ratio scale. The use of this concept is shown by application to the Metric of McCabe. These results are very important for selecting appropriate software metrics for software measurement and for developing tools which use software metrics to evaluate the "quality" of software.

A “card-marking” scheme for controlling intergenerational references in generation-based garbage collection on stock hardware

Abstract: Generation-based garbage collectors must detect references from older generations into younger ones in order to allow the independent scavenging of the younger generations [Lille83]. On stock hardware, the most efficient approach is to record which locations in older generations may hold pointers into younger generations as heap data are modified by the running program [Unga84]. At scavenge time, the remembered locations of older generations are checked to find any references to data in the generation(s) being scavenged. This ensures that any objects that are live because of pointers from older generations are found by the scavenging process.

Dependence analysis for pointer variables

Abstract: Our concern is how to determine data dependencies between program constructs in programming languages with pointer variables. We are particularly interested in computing data dependencies for langu...

Draft report on requirements for a common prototyping system

Abstract: 2 C o m m o n P r o t o t y p i n g S y s t e m D r a f t Nov 12, 1988 13:29 Behaviora l A b s t r a c t i o n and Typ ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-11 Modularity~ Scalabil i ty, and Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-12 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-12 W i d e s p e c t r u m Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-13 Rea l t ime and Concu r r en t C o m p u t a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-13 Para l le l C o m p u t a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-15 D i s t r i bu t ed C o m p u t a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-16 Knowledge-based . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-16 Syn tax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-17 Concre te S y n t a x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-17 Abs t r ac t S y n t a x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-18 Syn tax Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-19 Target Language Model ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-20 Behaviora l P ro to types of Target Componen t s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-20 S t ruc tu r a l P ro to types of Target Componen t s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-20 User Interface S u p p o r t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-20 A n E n v i r o n m e n t I n t r o d u c t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-2 P r o g r a m m i n g E n v i r o n m e n t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-2 Edi to r . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-3 Sys tem Def in i t ion Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-3 Debugg ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-3 Browsing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-4 D y n a m i c Load ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-4 W i n d o w i n g . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-5 Mul t i t a sk ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-5 Cond i t i on S igna l ing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-5 In t eg ra t i on of Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 -6 Extens ib i l i ty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-6 Pro to typing-Spec i f ic E n v i r o n m e n t Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . : . . . . . . . . . . . . 3-7 In fo rma t ion E x t r a c t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-7 P r e s e n t a t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-10 Incomple te P r o t o t y p e s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-10 Inc r emen ta l Deve lopment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-11 P r o t o t y p i n g User Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-11 Lifecycle Suppo r t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-12 Suppor t for Mul t ip le P ro to type r s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-12 R e l a t e d R e s e a r c h I n t r o d u c t i o n . . . . . . . . . . . . . . . . . . . . . . . . . . . i . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-2 P r o t o t y p i n g Languages as P r o d u c t i o n Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-2 T rans fo rming P ro to types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-3 Specif icat ion a n d P ro to types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 -4 Libraries of Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-5

Formulations and benefits of the law of demeter

Abstract: Our initial ideas on preventive maintenance of object-oriented systems were presented in [LHR88] which describes a set of guidelines called the "Law of Demeter". As a result of this publication we have received much feedback, as well as a detailed critique from [Sak89]. In this paper we expand on the initial ideas and present a new perspective with which to view the Law. This perspective is based on client/supplier relationships between methods and classes and allows a cleaner description of the benefits of the Law. This paper is also a reply to [Sak89] which was pointing out that the formulation of the Law for C++ needs additional work.At first sight, the idea of any rules or principles being superimposed on the creative mind seems more likely to hinder than to help, but this is really quite untrue in practice. Disciplined thinking focusses inspiration rather than blinkers it.

Object-oriented design: a responsibility-driven approach

Abstract: Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can ...

A denotational semantics of inheritance and its correctness

Abstract: This paper presents a denotational model of inheritance. The model is based on an intuitive motivation of the purpose of inheritance. The correctness of the model is demonstrated by proving it equi...

Spill code minimization techniques for optimizing compliers

Abstract: Global register allocation and spilling is commonly performed by solving a graph coloring problem. In this paper we present a new coherent set of heuristic methods for reducing the amount of spill ...

Computational reflection in class based object-oriented languages

Abstract: This paper describes various models of computational reflection in class based object oriented language. Two different approaches are covered: the meta-object approach which supposes that every obj...

A useful extension to Prolog's definite clause grammar notation

Abstract: Programming in a purely applicative style implies that all information is passed in arguments. However, in practice the number of arguments becomes large, which makes writing and maintaining such programs difficult. Two ways of getting around this problem are (1) to encapsulate information in compound structures which are passed in single arguments, and (2) to use global instead of local information. Both of these techniques are commordy used in imperative languages such as C, but neither is a satisfying way to program in Prolog:

Incremental distribution of timestamp packets: a new approach to distributed garbage collection

Abstract: A new algorithm for distributed garbage collection is presented. This algorithm collects distributed garbage incrementally and concurrently with user activity. It is the first incremental algorithm...

Determining average program execution times and their variance

Abstract: This paper presents a general framework for determining average program execution times and their variance, based on the program's interval structure and control dependence graph Average execution

Inheritance and synchronization with enabled-sets

Abstract: We discuss several issues related to the integration of inheritance and concurrency in an object-oriented language to support fine-grain parallel algorithms. We present a reflective extension of th...

Random number generators are chaotic

Abstract: We observe that pseudo-random number generators, familiar to all programmers, are examples of deterministic chaotic dynamical systems. We discuss the implications of this finding and compare computer generation of pseudo-random numbers to the theoretical ideal of a (noncomputable) random sequence.

A fast method dispatcher for compiled languages with multiple inheritance

Abstract: This paper addresses the problem of an efficient dispatch mechanism in an object-oriented system with multiple inheritance. The solution suggested is a direct table indexed branch such as is used i...

The effectiveness of error seeding

Abstract: Randomised error seeding is a technique which can be used to evaluate the ability of language processors to detect and report errors in source programs. The advantages and disadvantages of the method are discussed, and various strategies for using it presented. The lessons learned from experiments in using it on selected Pascal and Prolog systems are summarised, and suggestions for further research are offered.

A note on the detection of an Ada compiler bug while debugging an Anna program

Abstract: Anna [LvHKO84,LvH85] is a specification language designed for specifying Ada [Ada83] programs. Anna specifications provide formal, high-level descriptions of Ada programs. Anna, and for that manner any other specification language, has a variety of uses amongst which are formal documentation, rapid prototyping, program verification, runtime testing and the creation of self-checking software. This note illustrates the effectiveness of using formal specifications to debug programs and more specifically the use of Anna in developing and maintaining Ada programs. It reports an experiment in which an Anna program was being tested for consistency with its specifications. An inconsistency was discovered using the Anna tools. The formal analysis used to determine the cause of the error in the user program resulted in showing that the validated Ada compiler 1 (used in this experiment) was the culprit. The note also demonstrates the weaknesses of the current Ada compiler validation approaches. Many bugs in Ada compilers are beyond the capacity of validation suites and hence most validated Ada compilers still contain bugs. Unless formal methods are introduced, such bugs will continue to exist. Section 2 gives a brief overview of Anna 2, and also explains briefly the Anna Consistency Checking System. Section 3 introduces and explains the Anna program which revealed the compiler bug. Section 4 describes the main features of the process of debugging programs using formal specifications and then explains how this process was used in detecting the Ada compiler bug. Section 5 concludes this note.

The semantics of program dependence

Abstract: Optimizing and parallelizing compilers for procedural languages rely on various forms of program dependence graphs (pdgs) to express the essential control and data dependencies among atomic program...

AUTO STAR—a software development system

Abstract: This report summarizes the AUTO STAR project. AUTO STAR is a software development system which accepts the algebraic specification of a given software system and produces an Ada implementation of that system."In many applications, algorithms play almost no role, and certainly present almost no problem. The real problem is the mass of detailed requirements; and the only solution is the discovery or invention of general rules and abstractions which cover the many thousands of cases with as few exceptions as possible. This is what makes a program short, simple, and reliable, as compared with one which attempts to treat every case as a special case. But the discovery of such general rules and classifications demands at least the same inventive genius as that of a classificatory biologist, or the grammarian of a natural language, or even a theoretical physicist".

Incremental generation of parsers

Abstract: An LR-based parser generator for arbitrary context-free grammars is described, which generates parsers by need and processes grammar modifications by updating already existing parsers. We motivate ...

Process decomposition through locality of reference

Abstract: In the context of sequential computers, it is common practice to exploit temporal locality of reference through devices such as caches and virtual memory. In the context of multiprocessors, we beli...

A simple bucket-brigade advancement mechanism for generation-bases garbage collection

Abstract: Generation-based garbage collection systems use differing techniques to control the advancement of surviving data from each generation into the next (less frequently scavenged) generation. Moon's Ephemeral Garbage Collector [Moon84] copies all data that survive a scavenge into the next generation; Ungar's Generation Scavenging [Unga84] advances only those data that survive a specified number of scavenges.