PROJECT TITLE:
A Typed and Temporal Object-Oriented Technology
PI: Suad Alagic
FUNDING AGENCIES:
U.S. Army Research Office
Kansas Technology Enterprise Corporation.
PROJECT DURATION: May 1996 -- May 1999
Project Abstract
The goal of the project is to develop a basis for a typed, temporal logic-based, object-oriented technology. The underlying paradigm includes an object-oriented type system with advanced polymorphic features, a suitable temporal logic basis and the associated language, and an execution model. At least an advanced prototyping tool is also planned to be developed in the project. A flight simulator application has been selected in order to evaluate the benefits of the proposed technology.
A typed technology is defined in this project as a technology developed around an advanced type system in a way that never breaks the type system, neither at the level of user-oriented languages, nor in the underlying system architecture.
A typed, object-oriented paradigm to be developed in the project, will be equipped with appropriate temporal logic-based, high-level, constraint specification facilities suitable for complex systems. Contrary to the usual situation in strongly typed object-oriented programming languages, programming in the proposed environment will be declarative. The required logic basis will have well-defined semantics, but at the same time it will have an execution model.
Executable specifications are intended to be used in two ways. Their (almost) direct executability leads to a powerful prototyping tool for strongly typed object-oriented systems. When subject to the optimization techniques, those specifications become a basis for object-oriented query and other database languages. The project will also explore a prototype implementation of the optimization model based on a lower-level support of an existing, experimental, persistent object manager.
A flight simulator application will be elaborated in a joint research with the National Institute for Aviation Research in order to evaluate the viability of the proposed technology. The object-oriented technology is expected to prove its advantages because of the structural and behavioral complexity of (active) objects in such an environment. One of the goals of the project is to demonstrate that the proposed paradigm is suitable for expressing that complexity in a high-level, temporal logic based manner. At the same time, this application is one of those in which static type checking is expected to show its advantages.
Research computing infrastructure for this project is located in a recently developed Object Oriented Research Lab, equipped with a multiprocessor SUN server workstation, a multimedia SGI server workstation, and a collection high-quality NCD X-terminals. The equipment has been provided by a separate research instrumentation grant from the Department of Defense (Army Research Office, Defense University Research Instrumentation Program), for a related research project titled: ``Integrated Object-Oriented Environment for Modeling, Simulation, Prototyping and Active Database Management''. The software environment in this research lab, in addition to a complete object-oriented programming environment, includes advanced graphic facilities, two object-oriented and one extended relational database management systems, and as a separate package an object-oriented storage manager.
Publications
S. Alagic, Temporal object-oriented programming, Object-Oriented Systems, 6, pp. 1-42, 1999.
S. Alagic, Semantics of temporal classes, Information and Computation, accepted November 1999.
S. Alagic and M. Alagic, Order-sorted model theory for temporal executable specifications, Theoretical Computer Science, 179, pp. 273-299, 1997.
S. Alagic, Constrained matching is type safe, Proceedings of the 6th International Workshop on Database Programming Languages (DBPL), 1997, Lecture Notes in Computer Science, 1369, pp. 78- 96, 1998.
S. Alagic, J. Solorzano and D. Gitchell: Orthogonal to the Java imperative, Proceedings of ECOOP '98, Lecture Notes in Computer Science, 1445, pp. 212-233, 1998.
S. Alagic, A temporal constraint system for object-oriented databases, Proceedings of the Workshop on Constraints and Databases, Lecture Notes in Computer Science, Springer-Verlag, 1191, pp. 298-218, 1997.
J. Solorzano and S. Alagic, Parametric polymorphism for Java: A reflective solution, Proceedings of OOPSLA '98, pp. 216-225, ACM, 1998.
S. Alagic, Flight simulator database: Object-oriented design and implementation, In: A. Chaudhri and M. Loomis, Object Databases in Practice, pp. 79-94, Prentice-Hall, 1998.
S. Alagic, G. Nagati, J. Hutchinson and D. Ellis, Object-oriented flight simulator technology, Collection of Technical Papers, AIAA Conference, pp. 360-368, 1996.
S. Alagic, The ODMG object model: does it make sense?, Proceedings of the OOPSLA '97 Conference, pp. 253-270, ACM, 1997.
S. Alagic, Type checking OQL queries in the ODMG type systems, ACM Transactions on Database Systems, l999, to appear.
Orthogonal to the Java Imperative
Abstract
Three nontrivial limitations of the existing Java technology are considered from the viewpoint of object-oriented database technology. The limitations are: lack of support for orthogonal persistence, lack of parametric (and in fact bounded and F-bounded) polymorphism and lack of an assertion (constraint) language. These limitations are overcome by leaving Java as it is, and developing a declarative (query in particular) component of the Java technology. This declarative language is implemented on top of the Java Virtual Machine, extended with orthogonal and transitive persistence. The model of persistence also features complex name space management. Keywords: Declarative languages, orthogonal persistence, F-bounded polymorphism, Java Virtual Machine.
Parametric Polymorphism for Java: A Reflective Solution
Abstract
A number of inadequacies of existing implementation techniques for extending Java with parametric polymorphism are revealed. Homogeneous translations are the most space-efficient but they are not compatible with reflection, some models of persistence, and multiple dispatch. Heterogeneous translations, on the other hand, can potentially produce large amounts of redundant information. Implementation techniques that address these concerns are developed. In languages that support run-time reflection, an adequate implementation of parametric, bounded and F-bounded polymorphism is shown to require (reflective) run-time support. In Java, extensions to the core classes are needed. This is in spite of the fact that parametric polymorphism is intended to be managed statically.
Constrained Matching is Type Safe
Abstract
Temporally constrained matching in a persistent and declarative object-oriented system is introduced as a semantic alternative to the existing approaches to the covariance/contravariance problem. While the existing object-oriented type systems are based on subtyping, F-bounded polymorphism and matching, this language system is based entirely on inheritance, which is identified with matching. The type of matching used in this paper relies on the temporal constraint system. We prove that this constrained matching guarantees type safe substitutability even in situations where matching alone would not. This is possible only because the underlying formal system is semantically much richer than the paradigms of type systems. Its temporal constraint system can capture subtleties that go far beyond the level of expressiveness of object-oriented type systems. The temporal nature of the language and its distinctive orthogonal model of persistence make this language system successful in handling a variety of non-trivial applications. Keywords: Type systems, declarative programming, temporal logic, constraints, persistence.
Semantics of Temporal Classes
Abstract
A model theory of a typed, declarative, temporal object-oriented language system is presented. The declarative nature of the language makes it very different from the dominating procedural, strongly typed object-oriented programming languages. In this declarative system, methods are specified in a high-level, temporal constraint language. Two fundamental properties of these constraints are that they have an execution model and algebraic semantics. The model theory is based on temporal order-sorted algebras with predicates. A variety of orderings are explored in order to represent various types of inheritance, as well as the subtyping discipline. Temporal classes are viewed as temporal theories and some inheritance relationships as morphisms of temporal theories. A model of a temporal class is a temporal order-sorted structure with predicates which satisfies a set of temporal constraints specified in that class. Morphisms of those models are naturally required to preserve type coercions. A distinguished model of a temporal theory is constructed as a colimit of a suitably defined functor. This colimit construction reflects the temporal nature of the paradigm and generalizes the classical initial algebra semantics. In contradistinction to major difficulties in developing a model theory for full-fledged, typed procedural object-oriented languages, this paper shows that such a task becomes possible for a suitably defined declarative object-oriented language. This, in particular, leads to model-theoretic results on the preservation of the behavioral properties in the inheritance hierarchies.
Temporal Object-Oriented Programming
Abstract
An object-oriented, declarative, statically typed and temporal language system is presented. What makes this system very different from the currently prevailing strongly typed procedural object-oriented language systems is that methods are specified in a high-level, constraint sublanguage. The constraint sublanguage is based on a particular temporal paradigm, which has an execution model as well as the formal, initial model semantics. This constraint language system is seen as a non-traditional component of a sophisticated, typed object-oriented programming environment. It complements the procedural object-oriented languages in the areas of prototyping, simulation and databases. The paper covers the core ideas, the programming methodology, the type system, and the implementation techniques. Possible concurrent extensions and the limitations of the system are also discussed.
Order-sorted Model Theory for Temporal Executable Specifications
Abstract
An order-sorted, temporal programming paradigm is presented. It consists of a typed, modular, declarative language, its associated order-sorted temporal Horn clause logic basis, and a model theory generalizing order-sorted algebras with predicates to temporal order-sorted structures. The essence of this generalization is in allowing time-dependent predicates, so that a temporal order-sorted model amounts to a sequence of order-sorted equational models with predicates, one per each state. There are only three temporal operators: always, nexttime, and sometime. The restrictions on their usage guarantee the desired model theoretic properties. The main advantage of the presented paradigm in comparison with paradigms based on Horn-clause logic with equality is that it is more expressive, particularly so in representing properly state transitions, and other event-oriented, temporal behavioral properties of objects. At the same time, the generalized paradigm is proved to enjoy the initial model semantics. The rules for temporal-order sorted deduction are established as an appropriate generalization of the rules for order-sorted Horn-clause logic with equality. The initial model is a quotient temporal-order-sorted structure constructed from the initial temporal order-sorted structure and a congruence relation derived from a given set of temporal constraints. Temporal order-sorted model theoretic properties are also naturally established for temporal queries. The temporal constraint language has an execution model, and it is intended to be a basis for a prototyping tool for complex, typed, modular software systems.