PolyTOIL is a new statically-typed polymorphic object-oriented programming language that is provably type-safe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the type-checking rules, we have obtained a language that is very expressive while supporting modular type-checking of classes. The matching relation on types, which is related to F-bounded quanti cation, is used both in stating type-checking rules and expressing the bounds on type parameters for polymorphism. The design of PolyTOIL is based on a careful formal de nition of type-checking rules and semantics.

. Amidst rocketing numbers of enthusiastic Java programmers and internet applet users, there is growing concern about the security of executing Java code produced by external, unknown sources. Rather than waiting to find out empirically what damage Java programs do, we aim to examine first the language and then the environment looking for points of weakness. A proof of the soundness of the Java type system is a first, necessary step towards demonstrating which Java programs won't compromise computer security. We consider a type safe subset of Java describing primitive types, classes, inheritance, instance variables and methods, interfaces, shadowing, dynamic method binding, object creation, null and arrays. We argue that for this subset the type system is sound, by proving that program execution preserves the types, up to subclasses/subinterfaces. 1 Introduction Before the first complete Java language description was available [13] use of the language was extremely widespread and the ...

In this article we present Bali, the formalization of a large (hitherto sequential) sublanguage of Java. We give its abstract syntax, type system, well-formedness conditions, and an operational evaluation semantics. Based on these definitions, we can express soundness of the type system, an important design goal claimed to be reached by the designers of Java, and prove that Bali is indeed type-safe. All definitions and proofs have been done formally in the theorem prover Isabelle/HOL. Thus this article demonstrates that machine-checking the design of non-trivial programming languages has become a reality.

Overloading allows several function definitions for the same name, distinguished primarily through different argument types, and is typically resolved at compile-time. Inheritance allows subclasses to define more special versions of the same function, and is typically resolved at run-time. Modern object-oriented languages incorporate both features, usually in a type-safe manner. However, the combination of these features sometimes turns out to have surprising, and even counterintuitive, effects. We discuss why we consider these effects inadequate, and suggest alternatives. We explore the design space by isolating the main issues involved and analysing their interplay and suggest a formal framework describing static overloading resolution and dynamic function selection, abstracting from other language features. We believe that our framework clarifies the thought process going on at language design level. In particular we introduce a notion of soundness and completeness of an overloading res...

The introduction of parametric polymorphism in Java with translation approaches has been shown to be of considerable interest, allowing the denition of extensions of Java on top of the existing Virtual Machines. Homogeneous translations furthermore, seem to be more useful than heterogeneous, avoiding the continuous increase of library code with redundant information. At this time however, homogeneous approaches aren't as flexible as heterogeneous, with extensions failing to integrate well with base language typing. In this paper, using some of the features of the Core Reflection of Java, we introduce a homogeneous translation in which run-time information about instantiation of type-parameters is carried, allowing full integration of parameterized types with Java typing. Performance overhead is highly decreased using a brand new translation technique based on the deferring of the management of type information at load-time. The same power and flexibility of previous heterogeneous appro...

. There is a long-standing schism in object-orientation between the safe but rigid statically typed languages, and the exible but less safe dynamically typed languages. This paper presents an enhancement of the exibility and expressive power of a statically typed language, based on an inheritance mechanism which allows both compile-time and run-time construction of classes, as well as dynamic specialization of objects. This enhanced exibility supports better separation of concerns in large systems and allows for more elegant and maintainable designs. Submethoding|inheritance applied to behavioral descriptors|has been used for the construction of control structures for many years, in Beta. With dynamic inheritance, submethoding becomes more expressive, supporting control structures as rst class values which may be constructed and combined dynamically. Even though the concept of submethoding is missing from most other languages, the basic idea could be applied to any statically typed...

Abstract not found