ECOOP / Demonstrations

The demonstrations will be held Wednesday, 23 July, Thursday, 24 July, and Friday, July 15, parallel to the technical programme and the practitioner reports sessions. Each demonstration lasts 45 minutes and most of them will be presented twice. There are 8 demonstrations which will all take place in room S1/ 01/ 07, next to the main conference hall to attract many people. In the following all demonstrations are listed with their respective title, day, and time.

An AspectJ-enabled Eclipse Core Runtime

Martin Lippert , University of Hamburg & it-wps, Ltd.,
23 & 24 July 2003, 11:00 – 11.45

The Eclipse system can be used for different purposes. Where most developers use the Eclipse Java Tooling as an IDE, the Core Runtime Platform can be used as a framework or platform for general applications. It provides a basic runtime infrastructure that allows designing and implementing applications as combinations of plugins and extensions. The base plugin infrastructure is almost independent of any IDE-specific concepts. A goal of the version 2.2 of the Eclipse system is to improve this independence even further. Aside of the Eclipse plugin technology another interesting enhancement to the Java world is aspect-oriented programming using AspectJ. It allows you to modularize crosscutting concerns within aspects.
But what happens if you try to combine these two worlds (develop applications using the Eclipse plugin technology and AspectJ in combination)? Wouldn’t it be nice to develop a logging aspect, for example, as a single plugin? It would allow you to develop aspects that modularize crosscutting concerns across plugin boundaries. This demonstration presents an enhanced version of the Eclipse Core Runtime Platform that integrates load-time weaving functionality of the AspectJ language into the platform. The enhanced runtime allows you to stick aspects via plugins into your system without the need for recompilation across plugin boundaries. Because the implementation of the AspectJ-enabled version of the Core Runtime is backward compatible with the standard Core Runtime you can run the complete Eclipse Java IDE, for example, with it. It allows you to enhance existing Eclipse projects using the AspectJ programming language. Attendees of the presentation will see the running system, example plugins and how it can be used. The implementation of the enhanced Eclipse Core Runtime in the current version will be described as well.

Unified Data Architecture and The Latest About Caché 5

Sebastian Huber, InterSystems
Karin Schatz, InterSystems
23 & 24 July 2003, 11:45 – 12:30

Caché, the post-relational database from InterSystems, delivers breakthrough performance for massively scalable Web applications. Its rapid application development environment with advanced object technology lets you operate at Internet speed. Its multidimensional application and data server delivers lightning-fast performance.
The demonstration will provide an insight into Caché's Unified Data Architecture, which enables the synchronous access to data through object and relational technologies. The demonstration will also cover some of the new elements of Caché 5, InterSystems latest product release: WebServices, the Caché-XML interface, transactional Bit-Map Indices.
A free evaluation copy of Caché will be avaliable to all attendants of the demonstration session.

PROSE: From Hot-Fixes to Spontaneous Containers

Andrei Popovici, ETH Zuerich
23 & 24 July 2003, 13:30 – 14:15

In this demonstration we present PROSE (PROgrammable extenSions of sErvices), a tool for dynamic AOP. We show runtime adaptations of applications involved in a client-server interaction. The nodes we use for the client and the server (laptops) are suitable for mobile computing settings and for demonstrating hot-fixes. In the first part of the demonstration we show “aspect-browsing” with PROSE. We enhance the server node by dynamically weaving an aspect that identifies places of interest in the server node. After each weaving operation we use a visualization tool (which resides on a different node) to graphically display the join-points matched by the woven aspect. We modify the aspect and perform new weaving operations until we identify all join-points where corrections must be applied. In the second part of the demonstration we change the behavior of a running system. We define an aspect that encrypts sensitive parts of messages passed between the client and the server (credit card numbers). This aspect is then woven dynamically through all nodes. After the weaving operation, we show that both the server and the client are adapted, while from the client-server perspective the change is transparent.
This demonstration shows the usefulness of dynamic AOP with PROSE. The presented scenario is not comprehensive enough to cover all aspects of this technology. This approach can help to significantly reduce some of the cost associated to the maintenance of distributed systems and simplify the process of developing software for mobile computing scenarios.

SNAQue/J - A Program-Centric XML Binding Tool for Java

David Lievens, University of Strathclyde in Glasgow
23 & 24 July 2003, 14:15 – 15:00

More recently, a new wave of automated tools has emerged, offering increased binding support for the application programmer. Instead of generating the same interpretation for all their inputs, they take the intended interpretation as a parameter, validate its soundness with respect to the XML input, and then materialise it in the run-time of the host language. For many applications, this yields an important simplification of the programming model, as information about persons can now be presented to the programmer as, for example, instances of a class Person, rather than a stream of tokens or a tree.
Current binding tools that have been constructed in this spirit, such as JAXB, Castor, etc. take the document description (DTD, XML Schema) as the intended interpretation. They provide a conversion tool to generate document descriptions into language-specific type declarations.
SNAQue differs from these tools in that document descriptions play no role and type information is directly projected over XML documents by binding programs. This has a profound impact on the simplicity and flexibility of bindings. The programmer has now full control on the projected types - which may have been defined for the purpose of binding or simply reused from legacy code - and the design in which they should participate. Bindings can be defined with an arbitrary degree of granularity, and thus give access to fragments of possibly semistructured XML documents. Finally, irrelevant changes to the data have no impact on both projected types and binding programs.
We believe that the additional flexibility of this approach is essential for the construction of loosely coupled distributed systems that exchange XML data.

Nebras Enterprise: A Multi-Platform Framework for Building Enterprise Systems Based on UML Organization Models

Navid Khosravi, Nabras Informatics Co.
Mohammad Bakuii Katrimi, Nabras Informatics Co.
Farshid Zaker, Nabras Informatics Co.
Ahmad Zarei, Nabras Informatics Co.
Ali Kamandi, Nabras Informatics Co.
Mehdi Shourideh Yazdi, Nabras Informatics Co.
23 & 24 July 2003, 15:30 – 16:15

There have been many approaches to building enterprise systems but the most efficient ones are those which are integrated or configured according to the organization specifications and model. Using platform independent models (PIMs) in integrating enterprise systems is of great concern nowadays. In this demonstration we are going to present an approach to building and integrating enterprise systems which has many commonalities with OMG MDA concepts. There are two major integration points of view in this approach. First, integration from business process point of view and second, integration from object model point of view. We will present how these two objectives are achieved in Nebras Enterprise Framework. In this demonstration the following topics will be presented:

What are the important points in modeling an organization with UML in such an approach?
How can the document management system play an important role in entity and document integration?
Which requirements should the subsystems developers implement according to this approach?
How do we transform the model in order to make the enterprise shape itself according to achieved metadata at run-time?
How do we achieve a multi-platform enterprise including COM, CORBA, JAVA and .Net ?
How can such an approach accelerate the process of building enterprise systems?

Building Correct UML Models and Transforming them into Java Code Using OCLE

Dan Chiorean, Computer Science Research Laboratory - Babes-Bolyai University,
Adrian CARCU, Computer Science Research Laboratory - Babes-Bolyai University,
Mihai PASCA, Computer Science Research Laboratory - Babes-Bolyai University,
Cristian BOTIZA, Computer Science Research Laboratory - Babes-Bolyai University,
Sorin MOLDOVAN, Computer Science Research Laboratory - Babes-Bolyai University,
Horia CHIOREAN, Computer Science Research Laboratory - Babes-Bolyai University,
23 & 24 July 2003, 16:15 – 17:00

The object of this demonstration is to present the advantages that can be obtained from using OCLE to build correct UML models and transform them into Java code. The demonstration will focus on the following points:

Building, modifying and saving an OCLE project
Specifying, compiling, testing and saving different kinds of OCL constraints, both at the metamodel level and at the user model level.
Describing the different kinds of evaluation types: single evaluation, full batch evaluation and partial batch evaluation
Identifying the causes which determined some rules to fail or which generated evaluation exceptions, and eliminating those errors.
Checking XML documents described using a DTD – building the UML model for the DTD documents, filling the model with the information from the XML document, specifying and testing the semantical constraints and an overall checking of the documents.
Verifying a real UML model built using another tool (Rational Rose, Together, Poseidon) by fixing the identified errors and transferring the corrected model in XMI format.
Generating the appropriate code for an UML model, generating the code for the OCL specifications attached to that model, integrating the generated code into the application code and dynamically verifying the constraints for the application.

F-Script: An Object-Oriented Interactive Layer for the Mac OS X Object System

Philippe Mougin,
25 July 2003, 11:00 – 11:45

F-Script is a new object-oriented interactive and scripting layer specifically designed for the Mac OS X object system (i.e. Cocoa). F-Script provides scripting and interactive access to Mac OS X frameworks. It aims to be a useful and fun tool for both beginners and experts, allowing to interactively explore, test and use Cocoa-based objects and frameworks. Based on Smalltalk, F-Script provides a pure object-oriented environment that leverage Mac OS X technologies and includes significant innovations, like a high-level model for object manipulation and a graphical object browser. In this session, you'll have the opportunity to see demonstrations of:

The F-Script interactive environment, including the user-friendly support for object persistence and distributed objects.
An innovative graphical object browser which supports encapsulation and method invocation.
The OOPAL model, a new high level programming model supported by F-Script, which unify OOP and Array programming.
The integration between F-Script and Mac OS X frameworks.
The integration between F-Script and Mac OS X development tools (Project Builder, Interface Builder...)
F-Script Anywhere: dynamically taking control of running Mac OS X applications with F-Script.

Programming Transparently Adaptable and Distributed Applications with SALSA/IO

Carlos Varela, Rensselaer Polytechnic Institute,
Kaoutar El Maghraoui, Rensselaer Polytechnic Institute,
Travis Desell, Rensselaer Polytechnic Institute,
25 July, 11:45 – 12:30

We will demonstrate the SALSA actor programming language and the IO middleware system as software tools for building adaptable distributed applications over the Internet. SALSA (Simple Actor Language and Architecture) is an actor-based programming language for mobile and Internet computing. SALSA is an extension to the Java language. It has been designed and implemented to introduce the benefits of actor-based programming while keeping the advantages of object-oriented programming. SALSA simplifies programming open and reconfigurable distributed applications through its support for universal naming, active objects, migration, concurrency coordination primitives, and asynchronous message passing. SALSA programs are pre-processed into Java and hence preserve many of Java's useful object oriented concepts-encapsulation, inheritance, and polymorphism. It also takes full advantage of the portability features of Java and the existence of high-level libraries and APIs.
In the first part of this regular demonstration, we will present sample SALSA programs that illustrate the concepts of actors, migration, communication, coordination, and programmer's triggered dynamic reconfigurations. The second part of the demo will be devoted to IO. It will highlight middleware-triggered load balancing of SALSA programs. A set of applications will be run that show middleware adaptability to various level of inter-actor communication: from unconnected actor graphs to simulate independent or massively parallel applications, to sparse actor connectivity graphs, trees and hypercubes.

top