Static Typing for Object-Oriented Programming

Palsberg, Jens; Schwartzbach, Michael I.

doi:10.7146/dpb.v20i355.6585

Cited by 6 publications

(3 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…There seems to be no work-around to this problem with their system. (Palsberg and Schwartzback, 1991) and (Palsberg and Schwartzback, 1990) introduce the notion of substitution as a mechanism orthogonal to inheritance which, when combined with inheritance, provides a more general notion of subclassing. I have not studied this notion in detail, but suspect that the mechanism of class substitution can be viewed as an implicit form of bounded quanti cation in the original class and as a corresponding implicit type application in the actual class substitution.…”

Section: Comparison With Previous Workmentioning

confidence: 99%

See 1 more Smart Citation

A paradigmatic object-oriented programming language: Design, static typing and semantics

Bruce¹

1994

J. Funct. Prog.

109

View full text Add to dashboard Cite

To illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance.It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language.The design of TOOPL 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 supports the language design by providing a means to prove that the type-checking rules are sound, thus guaranteeing that the language is type-safe.While the semantics of our language is rather complex, involving fixed points at both the element and type level, we believe that this reflects the inherent complexity of the basic features of object-oriented programming languages. Particularly complex features include the implicit recursion inherent in the use of the keyword, self, to refer to the current object, and its corresponding type, MyType. The notions of subclass and inheritance introduce the greatest semantic complexities, whereas the notion of subtype is more straightforward to deal with. Our semantic investigations lead us to recommend caution in the use of inheritance, since small changes to method definitions in subclasses can result in major changes to the meanings of the other methods of the class.

show abstract

Section: Comparison With Previous Workmentioning

confidence: 99%

“…The paper by Palsberg and Schwartzback (1991) presents a theory of statically typed object-oriented languages in which subclasses preserve subtypes. Their system requires that types be finite sets of classes.…”

Section: Comparison With Previous Workmentioning

confidence: 99%

A paradigmatic object-oriented programming language: Design, static typing and semantics

Bruce¹

1994

J. Funct. Prog.

109

View full text Add to dashboard Cite

show abstract

“…The key difference between the first and the last two problems is that in the former case the subclass relationships are known, but in the latter case they are not. All published algorithms on type checking and type inference for object-oriented programs, for example [5,6,15,20,18,19,1,14,7], rely on knowing the subclass relationships, and if there is a separate notion of typing and subtyping, then, of course, the algorithms rely on knowing the definition of subtyping. Hence, they do not apply to the typability and class-graph inference problems that we study in this paper.…”

Section: Adaptive Programmingmentioning

confidence: 99%

Class-graph inference for adaptive programs

Palsberg

1997

Theory Pract. Obj. Syst.

Self Cite

View full text Add to dashboard Cite

Software generators can adapt components to changes in the architectures in which the components operate. The idea is to keep the architecture description separate and let the software generator mix it with specifications of each component. Adaptation is done by regeneration: when the architecture changes, the components are regenerated.A software component will usually be written with a particular architecture in mind. This raises the question: how much has it committed to the particular structure of that architecture? To put it in a nutshell: How flexible is a given software component?In this paper we study this question in the setting of Lieberherr's adaptive programming. Lieberherr uses class graphs as the architecture and so-called adaptive programs as the software components. We present a polynomial-time class-graph inference algorithm for adaptive programs. The algorithm builds a representation of the set of class graphs with which a given adaptive program can work. It also decides if the set is non-empty, and if so it computes a particularly simple graph in the solution set. Several toy programs have been processed by a prototype implementation of the algorithm.

show abstract

Attaching Second-Order Types to Methods in an Object-Oriented Language

Caseau¹,

Perron

ECOOP’ 93 — Object-Oriented Programming

View full text Add to dashboard Cite

Static Typing for Object-Oriented Programming

Cited by 6 publications

References 33 publications

A paradigmatic object-oriented programming language: Design, static typing and semantics

A paradigmatic object-oriented programming language: Design, static typing and semantics

Class-graph inference for adaptive programs

Attaching Second-Order Types to Methods in an Object-Oriented Language

Contact Info

Product

Resources

About