[Prev][Next][Index][Thread]

Paper on OOL design and semantics



Date: Fri, 31 Jan 92 12:03:56 EST
Return-Path: <kim@cs.williams.edu>
To: objecttypes@daimi.aau.dk, types@theory.lcs.mit.edu

The paper, 
       A Paradigmatic Object-Oriented Programming Language: 
             Design, Static Typing and Semantics
                          by
                      Kim B. Bruce
                    Williams College

is available by anonymous ftp from bull.cs.williams.edu, (for those
whose name servers have difficulty finding the machine, its numeric
address is 137.165.5.2).

Login as anonymous and type your id as password when requested.  To get to 
the proper directory, type:
	cd pub/kim
To receive the paper, type
	get ObjDesign.dvi

The README file in the same directory contains descriptions of other
papers which can also be found in the same directory.

Those without access to ftp should send a request to kim@cs.williams.edu
for a paper copy.  (Be sure to include a complete mail address.)

Be aware that the paper is long (58 pages), though hopefully more readable
than the average technical paper in semantics.  I made a concerted effort 
to put in a great deal of motivation (probably half the paper) in order to 
make the technical results more understandable.

(For those of you who attended POPL, this is one of the papers Luca Cardelli
referred to as "suggested reading" at the end of his invited lecture.)

The abstract follows: 

ABSTRACT
In order to illuminate the fundamental concepts involved in object-oriented 
programming languages, we describe the design of a statically-typed 
paradigmatic functional object-oriented programming language which supports 
classes, objects, methods, hidden instance variables, subtypes, and 
inheritance.  We provide type-checking rules and a denotational semantics of 
this language.  The language design has been guided by an analysis of the 
semantics of the language, which is given in terms of a
model of the F-bounded second-order lambda calculus with fixed points
at both the element and type level.  This semantics allows us to prove
that the type-checking rules are sound, providing a type-safe programming
language.  

While the semantics of our language is rather complex, involving 
fixed points at both the element and type level, we believe that this
complexity underlies the basic concepts of object-oriented programming
languages.  Inherently complex features include the implicit recursion
inherent in the use of the keyword, self, to refer to the current object, 
and its corresponding type, MT.  The notions of subclass and inheritance 
introduce the greatest semantic complexities, whereas the notion of subtype 
seems relatively straightforward.

In order to provide a more intuitive introduction to the language, both 
syntax and semantics are introduced in a gradual style with informal 
discussion before more formal definitions.  Several examples
of classes and functions written in the language are provided as well.  
We also discuss the impact on program development of the complexity of 
these notions in object-oriented languages.

-----------------

Since the paper has not yet been submitted for publication, I would be
very grateful for any comments or corrections.  In particular comments
on parts that need further clarification are particularly welcome.

	Kim Bruce