We present a simple extension of typed -calculus where functions can be overloaded by putting different "branches of code" together. When the function is applied, the branch to execute is chosen according to a particular selection rule which depends on the type of the argument. The crucial feature of the present approach is that the branch selection depends on the "run-time type" of the argument, which may differ from its compile-time type, because of the existence of a subtyping relation among types. Hence overloading cannot be eliminated by a static analysis of code, but is an essential feature to be dealt with during computation. We obtain in this way a type-dependent calculus, which differs from the various -calculi where types do not play any role during computation. We prove Confluence and a generalized Subject-Reduction theorem for this calculus. We prove Strong Normalization for a "stratified" subcalculus. The definition of this calculus is guided by the understand...

In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir classes. A mixin declaration in Jam is similar to a Java heir class declaration, except that it does not extend a fixed parent class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for classes and interfaces, mixin names are reference types, and all the classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The ...

While static typing is widely accepted as being necessary for secure program execution, dynamic typing is also viewed as being essential in some applications. Dynamics have been proposed as a way of introducing dynamic typing into statically typed languages, with particular application to programming in distributed environments. However proposals for incorporating dynamics into languages with parametric polymorphism, such as ML, have serious shortcomings. A new approach is presented to extending ML-like languages with dynamic typing. This approach has particular usefulness for programming in distributed environments, where many of the practical applications of dynamic typing arise. At the heart of the approach is the use of type-based computation, where polymorphic functions may analyse the structure of their type arguments. This approach solves several open problems with the use of traditional dynamics in polymorphic languages. Type-based computation is also the basis for programmer-d...

We define a specification formalism (formally, an institution) which provides a notion of dynamic type (the type which is associated to a term by a particular evaluation) and late binding (the fact that the function version to be invoked in a function application depends on the dynamic type of one or more arguments). Hence, it constitutes a natural formal framework for modeling objectoriented and other dynamically-typed languages and a basis for adding to them a specification level. In this respect, the main novelty is the capability of writing axioms related to a given type which are not required to hold for subtypes, hence can be "overridden" in further refinements, thus lifting at the specification level the possibility of reusing code which is offered by the object-oriented approach.

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...

PORK is an object system which brings a conventional object-oriented language closer to the requirements of frame-based programming. It only provides a very limited set of features (on top of the base object system itself), and aims to achieve seamless integration with conventional programming. PORK is implemented as a portable metalevel extension of the Common Lisp Object System (CLOS). It extends CLOS by adding the following concepts: ffl Named objects. These simplify debugging and linked frame model construction. Collections of named objects (called "namespaces") can also be used as a low-level implementation vehicle for knowledge bases. ffl References to nonexisting named objects. Programs can manipulate objects that have not yet been created. This greatly simplifies definition of complex linked frame models with circular references. ffl Slots with multiple values, and a mechanism for defining an access interface. ffl Automatic updating of inverse slots. iii iv Contents 1 In...

Object-oriented paradigm has been adopted by many database systems... In this paper we show that odmg-compliant object-oriented databases are not sufficient, and we propose a way to manage persistence using metamodeling.

A serious problem of many transformation-based generators is that they are trying to achieve three mutually antagonistic goals simultaneously: 1) deeply factored operators and operands to gain the combinatorial programming leverage provided by composition, 2) high performance code in the generated program, and 3) small (i.e., practical) generation search spaces. The hypothesis of this paper is that current generator structures are inadequate to fully achieve these goals because they often induce an explosion of the generation search space. Therefore, new architectures are required. A generator has been implemented in Common LISP to explore architectural variations needed to address this quandary. It is called the Anticipatory Optimization Generator (AOG ) because it allows programmers to anticipate optimization opportunities and to prepare an abstract, distributed plan that attempts to achieve them. More generally, AOG uses several strategies to prevent generation search spaces from becoming an explosion of choices but the fundamental principle underlying all of them is to solve separate, narrow and specialized generation problems by strategies tailored to each individual problem rather than attempting to solve all problems by a single, general strategy. A second fundamental notion is the preservation and use of domain specific information as a way to gain leverage on generation problems. This paper will focus on two specific mechanisms: 1) Localization: The generation and merging of implicit control structures, and 2) Tag-Directed Transformations: A new control structure for transformation-based optimization that allows differing kinds of domain knowledge (e.g., optimization knowledge) to be anticipated, affixed to the component parts in the reuse library, and trig...

Even though federated multidatabase systems solve most of the issues in integrating heterogeneous data sources, they do not solve what we call data access heterogeneity : i.e. they do not allow users to structure and manage in the same way persistent, volatile and distributed data with the tools that match their needs. To solve this problem, we propose to add generic MDBS management facilities into a general purpose object oriented programming language. This extension is mainly based on new transactional and view approaches and the resulting system can be completely customized in order to match the needs of its users. An implementation of this system for Java, named JavaViews, currently allows to integrate ODBC as well as Versant or Poet databases. 1 Introduction The growing amount of data that can be found through various media, including the Internet, had led to the heterogeneity of software throughout they are accessed, of hardware on which they are stored, and of the models used ...

Abstract not found