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)
AbstractSeparation 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.
http://www.research.ibm.com/hyperspace/HyperJ/ECOOP99-Demo-Proposal.html (Full demo description)
ScheduleWednesday, June 16, 14:30 - 15:15
Thursday, June 17, 11:00 - 11:45
D2: TYped Concurrent Objects
AbstractWe 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.
ScheduleWednesday, June 16, 11:00 - 11:45
Thursday, June 17, 14:30 - 15:15
D3: Diff: the System of Automatic Differentiation on C/C++
AbstractThe 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.
ScheduleWednesday, June 16, 12:15 - 13:00
Thursday, June 17, 15:45 - 16:30
D4: The Oberon Slicing Tool
AbstractProgram 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 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.
ScheduleWednesday, 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
AbstractBad 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.
ScheduleWednesday, June 16, 15:45 - 16:30
Thursday, June 17, 17:00 - 17:45