Wednesday, 6 November 15:30-17:00 Ballroom 6C
Technical Papers: Languages
Chair: Guy Steele
This session is a collection of innovative language-level research and techniques that advances the state-of-art in objects. The first paper aims to define, implement and illustrate a portable serialization technique for CORBA objects based on reflection, in particular using open compilers. The second paper extends the well-known design language, live sequence charts, into a powerful executable language thereby allowing detailed description of object interaction in a succinct fashion. The third paper combines the traditional constraint-solving language and object-oriented language to derive a powerful framework for solving combinatorial optimization problems.
Portable Serialization of CORBA Objects: A Reflective Approach
The objective of this work is to define, implement and illustrate a portable serialization technique for CORBA objects based on a reflective approach. Through open compilers facilities the internal state of CORBA objects is obtained and transformed into a portable format thanks to CORBA facilities. This state can be restored and used by objects developed using different languages and running on different software platforms. A tool was developed and applied to a Chat application as a case study. The proposed technique is used to exchange state information between a C++ and a Java incarnation of this CORBA service. An observer tool enables the object state to be displayed and analyzed by the user. The applicability of this technique to various domains is also discussed. We finally advocate that reflection (and related techniques) is a powerful concept to extend the work presented in this paper.
Multiple Instances and Symbolic Variables in Executable Sequence Charts
We extend live sequence charts (LSCs), a highly expressive variant of sequence diagrams, and provide the extension with an executable semantics. The extension involves support for instances that can bind to multiple objects and symbolic variables that can bind to arbitrary values. The result is a powerful executable language for expressing behavioral requirements on the level of inter-object interaction. The extension is implemented in full in our play-engine tool, with which one can execute the requirements directly without the need to build or synthesize an intra-object system model. It seems that in addition to many advantages in testing and requirements engineering, for some kinds of systems this could lead to the requirements actually serving as the final implementation.
A Constraint-Based Architecture for Local Search
Combinatorial optimization problems are ubiquitous in many practical applications. Yet most of them are challenging, both from computational complexity and programming standpoints. Local search is one of the main approaches to address these problems. However, it often requires sophisticated incremental algorithms and data structures, and considerable experimentation. This paper proposes a constraint-based, object-oriented, architecture to reduce the development time of local search algorithms significantly. The architecture consists of declarative and search components. The declarative component includes invariants, which maintain complex expressions incrementally, and differentiable objects, which maintain properties that can be queried to evaluate the effect of local moves. Differentiable objects are high-level modeling concepts, such as constraints and functions, that capture combinatorial substructures arising in many applications. The search component supports various abstractions to specify heuristics and meta-heuristics. We illustrate the architecture with the language Comet and several applications, such as car sequencing and the progressive party problem. The applications indicate that the architecture allows for very high-level modeling of local search algorithms, while preserving excellent performance.