Live demonstrations of the very latest object-oriented technology are an exciting part of every ECOOP conference, offering an excellent occasion for discussing technical aspects of object-oriented applications, tools and systems. These demonstrations are given by technical members of their implementation team. Presentations are in the form of running computer programs.

Nr Demonstrators Title Wednesday Thursday
D1 H. Ossher, P. Tarr HyperJ(TM): Multi-Dimensional Separation of Concerns for Java(TM) 14:30-15:15 11:00-11:45
D2 L. Lopes, F. Silva, V. Vasconcelos TYped Concurrent Objects 11:00-11:45 14:30-15:15
D3 V. Katkov Diff: the System of Automatic Differentiation on C/C++ 12:15-13:00 15:45-16:30
D4 C. Steindl The Oberon Slicing Tool 17:00-17:45 12:15-13:00
D5 K. De Hondt, P. Steyaert The Classification Browser: Architecural Recovery and Maintenance in Large, Evolving Smalltalk Systems 15:45-16:30 17:00-17:45

D1: HyperJ(TM): Multi-Dimensional Separation of Concerns for Java(TM)


  • Harold Ossher (IBM T.J. Watson Research Center)
  • Peri Tarr (IBM T.J. Watson Research Center)
  • Abstract

    Separation of concerns is at the core of object-oriented software development. It has the potential to impart many well-known benefits, but only if the concerns that are separated match those needed for particular tasks. Unfortunately, different tasks can involve dramatically different concerns. For example, changing a data representation in an object-oriented system might involve just writing one subclass, whereas adding a new feature typically involves invasive changes to many classes: its code is scattered across multiple classes, and tangled with other code. Modularization may be needed by class, feature, "aspect," "role," "variant," and/or many other criteria

    Multi-dimensional separation of concerns is a new approach that supports clean separation of multiple, potentially overlapping concerns simultaneously, with on-demand remodularization. Developers can choose the best modularization for each task, reducing impact of change substantially and facilitating refactoring and reengineering. Support for on-demand modularization is a major advance over earlier mechanisms, such as subject-oriented programming and aspect-oriented programming.

    This demonstration will present HyperJ(TM), which supports multi-dimensional separation of concerns for Java(TM). HyperJ provides the ability to identify concerns, specify modules in terms of those concerns, and synthesize systems and components by integrating those modules. The tool works with and produces standard Java class files.

    URL (Full demo description)


    Wednesday, June 16, 14:30 - 15:15
    Thursday, June 17, 11:00 - 11:45


    D2: TYped Concurrent Objects


  • Luís Lopes (Faculdade de Ciências, Universidade do Porto)
  • Fernando Silva (Faculdade de Ciências, Universidade do Porto)
  • Vasco Vasconcelos (Faculdade de Ciências, Universidade de Lisboa)
  • Abstract

    We present a strongly typed, polymorphic, concurrent, object-based programming language called Core-TyCO and its run-time system. The language is based on the TyCO object-calculus, a form of the pi-calculus, where the main abstractions are collections of methods (objects) and asynchronous messages (method invocations). The calculus is reminiscent of Abadi and Cardelli's object calculus. Core-TyCO grows from the calculus by introducing a small number of builtin constructs (conditionals, for example), data-types and derived constructs to make programming easier. The language was designed to serve as a core system for higher level concurrent, object-oriented idioms.

    Core-TyCO is provided with a compiler from source to an intermediate language, an assembler that creates a byte-code representation from the intermediate code, and an emulator. The compiler is coupled with a type system that infers the types of names in the program and other important name usage information. The assembler analyzes the intermediate code, applies some optimizations and generates a very compact byte-code format file.

    The byte-code emulator is very compact and uses a heap for dynamic data-structures, a run-queue for fair scheduling of byte-code blocks and two stacks for keeping local variable bindings and for evaluating builtin expressions. It is implemented in about 3k lines of C code and the binary uses just 29k. The implementation combines some technology from the STG-machine (functional programming), the WAM (logic programming) and the Pict abstract machine.

    Preliminary performance results show that Core-TyCO performs close to other concurrent languages with objects such as Pict and Oz in most applications and surpasses them in object intensive applications.

    Demonstration Notes


    Wednesday, June 16, 11:00 - 11:45
    Thursday, June 17, 14:30 - 15:15


    D3: Diff: the System of Automatic Differentiation on C/C++


  • Vladislav Katkov (Institute of Engineering Cybernetics, Minks)
  • Abstract

    The operation of differentiation is well formalized in the mathematics and consequently can be effectively implemented on computer and used in various applications.

    The described DIFF system calculates a partial and total derivatives, derivatives of implicit functions, derivatives of functions given as sequence of formulas, Jacobian (first order derivatives matrix), Hessian (second order derivatives matrix), Taylor's series. For inclusion of differentiation in the C-programs the language was extended by the description of functions and was complemented by corresponding library of functions for calculation of derivative, Jacobian, expansion in Taylor's series and other means. The transformation from the extended C language in the standard C representation carries out by specially written Preprocessor. We prepare the C-program, extended by operations of differentiation, with the help of the special tool Environment included in Microsoft Developer Studio Visual C++ in standard manner.

    Our system may be used for calculation of equation roots, function minimization, sensitivity analysis of finite-difference schemes, for solution of differential equations via series expansion, analysis of function's behaviour, estimation of remainder terms of quadrature formulas and series, for singular points analysis of differential equations, and many other.

    System has been developed by means of object-oriented technique and operates on IBM PCs under Windows 95.


    Wednesday, June 16, 12:15 - 13:00
    Thursday, June 17, 15:45 - 16:30


    D4: The Oberon Slicing Tool


  • Christoph Steindl (Institute für Praktische Informatik, Johannes Kepler University Linz)
  • Abstract

    Program slicing is a novel program analysis technique. It is mainly used during debugging and reengineering. It tries to eliminate all parts from the program that are not currently of interest to the programmer. Therefore, the programmer clicks on a statement (which is of interest to him, e.g. because the value of a variable is wrong) and the program slicer highlights all program statements that might have produced the erroneous value. Relationships between program entities like variable definitions and variable usages are visualized. The Oberon Slicing Tool
  • computes program slices of Oberon-2 programs (no restrictions on the programs, i.e. they may use structured types (records and arrays), global variables of any type, objects on the heap; functions may have arbitrary side-effects; procedures may be nested; there may be recursion and dynamic binding due to type-bound procedures (methods) and procedure variables (function pointers); and the program can consist of modules).
  • is extremely fast (slicing information is computed within a few seconds, slices are computed without any delay at all).
  • uses static slicing (which produces bigger slices than dynamic slicing but is much more efficient)
  • can compute intraprocedural, interprocedural and intermodular slices.
  • can handle procedural and object-oriented programs.
  • does so in an expression-oriented way (finer grained than statement-oriented slicing).
  • uses user-feedback to restrict the effects of aliases and dynamic binding.
  • uses a repository to store the computed slicing information which can be re-used later when importing already sliced modules.
  • implements the Model-View-Controller concept (i.e. it is possible to have multiple views of the same slice that are kept consistent).
  • Only a few tools exist for program slicing. All of them have problems with at least some of the features of the Oberon Slicing Tool. We will demonstrate all these features at the demonstration.

    Demonstration Notes


    Wednesday, June 16, 17:00 - 17:45
    Thursday, June 17, 12:15 - 13:00


    D5: The Classification Browser: Architecural Recovery and Maintenance in Large, Evolving Smalltalk Systems


  • Koen De Hondt (MediaGeniX n.v.)
  • Patrick Steyaert (MediaGeniX n.v.)
  • Abstract

    Bad software comprehension, poor effort estimation and poor insight into the effects of changes make it hard to evolve and maintain software correctly. Software documentation as we know it today does not appear to help, because either documentation is nonexistent, or it is not in-sync with the source code, or it is not targeted to the maintenance and evolution problems we face today. For Smalltalk, several useful re-engineering tools have been built to analyse, reverse engineer, and evolve software systems. Individually, these tools solve only part of the problem, and in their current state, the results of the different tools are hard to combine.

    The Classification Browser and the underlying Software Classification Model provide the platform to integrate different re-engineering tools. The Classification Browser is a browser framework that is extensible with additional tools. The Software Classification Model is used to integrate different models to represent parts of Smalltalk systems (classes and methods, method invocation structures, Smalltalk categories, Envy applications and user-defined structures). In the demonstration, the Classification Browser and some integrated tools from other research groups (Duploc, Smalllint, Rewrite Rule Editor, Smalltalk Open Unification Language) will be used to perform recovery and maintenance tasks on a Smalltalk framework.



    Wednesday, June 16, 15:45 - 16:30
    Thursday, June 17, 17:00 - 17:45