16th European Conference on Object-Oriented Programming
University of Málaga, Spain
June 10-14, 2002

Technical programme > Demos

General Information
Call for Contributions
Technical Programme
Useful Information
Social Programme

<< Site map >>
<< History file >>

Ecoop 2002 is organized in cooperation with:
Important dates
Oct 01
Nov 01
Dec 01
Jan 02
Feb 02
Apr 02
May 02
Jun 02

You are the visitor number

from 4th October 2001.


Technical programme - Demos

Wed 12/6
Thu 13/6
Fri 14/6
Room A
Room B
Room A
Room B
Room A
Room B
Coffee break


ID Title Contact person Days
01 Developing Tooling with Eclipse for Embedded Java Development Aldo Eisma and Susan Iwai (Object Technology International AG Wed 16:30
Fri 11:30
02 Experiences in Developing an Aspect-Oriented Development Tool in AspectJand Eclipse Adrian M. Colyer and Susan Iwai (Object Technology International AG Thu 11:30
Fri 12:15
03 Separating Computation from Coordination for Java Applications Joao Gouveia, Georgios Koutsoukos, Michel Wermelinger, Luis Andrade and José Luiz Fiadeiro (Oblog Software SA) Thu 12:15 Thu 17:15
04 Squeak: the Open-Source Smalltalk

Stephane Ducasse, Software Composition Group (SCG-IAM, University of Berne)

Wed 11:30
Fri 14:30

05 SOUL: Supporting Object-Oriented Software Development with Logic Meta Programming Tom Tourwe, Johan Brichau (Universiteit Brussel) and Kim Mens (Université catholique de Louvain)

Wed 12:15
Fri 15:15

06 Typed Concurrent Objects Vasco T. Vasconcelos (University of Lisboa) and Luis Lopes (University of Porto)

Thu 11:30
Thu 16:30

07 LAVA -Object-based Dynamic Inheritance for Java Günter Kniesel, Uwe Bardey,Tobias Windeln and Jörg Gonska (University of Bonn)

Wed 14:30
Thu 14:30

08 A Threaded Code Interpreter for Rotor, Microsoft’s Shared Source Implementation of the Common Language Infrastructure (CLI) Yahya H. Mirza (Aurora Borealis Software) Wed 15:15
Thu 15:15
09 GME: A Reflective Environment for Domain-Specific Modeling Akos Ledeczi (Institute for Software Integrated Systems, Vanderbilt University)

Wed 14:30
Fri 14:30

10 Using the Montages Language Prototyping Tool to add Object-Orientedness to Xasm Philipp W. Kutter (Applied Formal Methods Institute AG and ETH Zurich) Wed 11:30 Wed 16:30
11 SoftwarePot:Encapsulated File Spaces for Secure Software Circulation Yoshihiro Oyama, Kazuhiko Kato (Japan Science and Technology Corporation), Katsunori Kanda (University of Tsukuba) Thu 14:30
Fri 11:30
12 LES Objects: A Model-based Code Generation Environment for Object-Oriented Conceptual Modeling of Web Application Interfaces Jaime Gómez, Cristina Cachero & Antonio Párraga (Web Engineering Group, University of Alicante) Wed 17:15 Thu 16:30
13 Octopus: A PostWIMP Framework for New Interaction Techniques Mads Brřgger Enevoldsen, and Michael Lassen (Computer Science Dept., University of Aarhus)

Wed 15:15
Thu 15:15


D01: Developing Tooling with Eclipse for Embedded Java Development

Presenters: Aldo Eisma and Susan Iwai, Object Technology International AG

Eclipse is an open source, extensible, tooling platform (see http://www.eclipse.org/). The platform was built using its own Java IDE hat includes Java development support features such as refactoring, version control, compiling and debugging. The Eclipse platform is designed to be easily extended by plugins to create tools for other languages and applications.
For the Eclipse-based IBM WebSphere Device Developer product we developed a set of plugins to support building and launching of embedded applications (with support for various platforms, such as J2ME/MIDP, PocketPC and PalmOS). This demonstration presents the results of our work as an illustration of the possibilities that the Eclipse platform gives to tool developers. The demonstration wil focus on the integration of the SmartLinker(tm) Java optimization and packaging tool in Eclipse. The presentation will also show how Eclipse integration facilitates collaboration among distributed labs when we illustrate how we set up and run experiments collaboratively between OTI's labs and our research partners at the IBM TJ Watson Research Center in New York.


  • Wednesday, June 12, 16:30
  • Friday, June 14, 11:30


D02: Experiences in Developing an Aspect-Oriented Development Tool in AspectJ and Eclipse

Presenters: Adrian M. Colyer and Susan Iwai, Object Technology International AG

Eclipse is an open source, extensible, tooling platform (see http://www.eclipse.org/). The platform was built using its own Java IDE that includes Java development support features such as refactoring, version control, compiling and debugging. The Eclipse platform is designed to be easily extended by plugins to create tools for other languages and applications.
The AspectJ development tools plug-in provides support for aspect-oriented software development in the Eclipse environment using the AspectJ programming language. AspectJ is an extension to the Java programming language that supports modularization of cross-cutting concerns. The demonstration will show how the Eclipse Java support is being extended to provide an AspectJ aware editor, an outline view allowing navigation of cross-cutting structure, support for multiple build configuration files within a project (giving selective application of aspects), an AspectJ builder for compilation, task-list integration and several other features.


  • Thursday, June 13, 11:30
  • Friday, June 14, 12:15

D03: Separating Computation from Coordination for Java Applications

Presenters: Joao Gouveia, Georgios Koutsoukos, Michel Wermelinger, Luis Andrade and José Luiz Fiadeiro, Oblog Software SA

Coordination contracts are a modelling primitive, based on methodological and mathematical principles, that facilitates the evolution of software systems. The use of coordination contracts encourages the separation of computation from coordination aspects, and the analysis of which are the ``stable'' and ``unstable'' entities of the system regarding evolution. Coordination contracts encapsulate the coordination aspects, i.e., the way components interact, and as such may capture the business rules that govern interactions within the application and between the application and its environment.
System evolution consists in adding and removing contracts (i.e., changing the business rules) between given components (the participants of the contract). As a result of an addition, the interactions specified by the contract are superposed on the functionalities provided by the participants without having to modify the computations that implement them. In fact, the components are completely unaware they are being coordinated. The contracts specify a set of rules, each with a triggering condition (e.g., a call to a method of one participant), and a rule body stating what to do in that case. Contracts are also unaware of the existence of other contracts. This facilitates enormously incremental system evolution, because explicit dependencies between the different parts of the system are kept to a minimum, and new contracts can be defined and added to the system at any time (even run-time), thus coping with changes that were not predicted at system design time.
For this approach to be usable in real applications, it requires a tool to support system development and evolution using coordination contracts. Capitalising on the expertise of Oblog Software in building development tools, the current version of the Coordination Development Environment (CDE) helps programmers to develop Java applications using coordination contracts. More precisely, it allows to write contracts, to translate them into Java, and to register Java classes (components) for coordination. The code for adapting those components and for implementing the contract semantics is generated based on a micro-architecture that is based on the Proxy and Chain of Responsibility design patterns. The CDE also includes an animation tool, with some reconfiguration capabilities, in which the run-time behaviour of contracts and their participants can be observed using sequence diagrams, thus allowing testing of the deployed application.
CDE is written in Java and requires JDK 1.2. It is freely available for download from www.atxsoftware.com/agility.html.


  • Thursday, June 13, 12:15
  • Thursday, June 13, 17:15


D04: Squeak: the Open-Source Smalltalk

Presenters: Stephane Ducasse, Software Composition Group (SCG-IAM, University of Berne)

Squeak is the open source Smalltalk being developed by Dr. Alan Kay and a part of the original team that invented Smalltalk the first object-oriented language, multi-windowing systems, bitmap manipulation at Xerox Lab. There also were pioneers in the use of GC, virtual machines, mouse, bitmap devices. Macintosh with the Lisa copied them. However, Squeak is more than just redoing the past. Squeak has strong multimedia and network capabilities. Moreover, Squeak is a platform used for experimenting all kinds of new topics related object-oriented programming from new object model such as mixin to new ways of teaching OO.

The demo will show the following aspects of Squeak:

  • New graphics support (Morphic from Self, WarpBlt new bit manipulation)
  • Net support (pop, html, flash reader)
  • Web server (Comanche a Apache like web server written in Squeak, SeaSide for dynamic html page generation)
  • 3D engine
  • Music and sound support (sample, midi, digitalizer)
  • Voice generation
  • eToy: an environment for teaching kids to program.
  • Handwriting recognition
  • Current projects developed in Squeak

Moreover Squeak runs on all the possible hardware and OS. Indeed the VM is also open source and written in a subset of Squeak and translated to C.

WebPages: http://www.squeak.org/


  • Wednesday, June 12, 11:30
  • Friday, June 14, 14:30


D05: SOUL: Supporting Object-Oriented Software Development with Logic Meta Programming

Presenters: Tom Tourwe, Johan Brichau, Universiteit Brussel, Kim Mens, Université catholique de Louvain

At the Programming Technology Lab of the Vrije Universiteit Brussel, research is being conducted on how the technique of logic meta-programming can be used to build state-of-the-art software development support tools. By capturing and expressing the interaction between the higher levels of software development (design, analysis, etc...) and the actual implementation level, we can co-evolve the source code and the higher-level software artifacts. The goal is to keep design, documentation and source code synchronised when the software evolves.
The interaction between source code and higher-level artifacts is expressed using a logic meta-programming language. This approach allows us to express these artifacts in a declarative way as meta-information of the program itself. This information can be actively used by the programming environment to guide the software development process in a variety of ways: to generate design from implementation and vice-versa; to provide support for refactoring, software reuse and evolution, aspect-oriented programming, generative programming, etc...
During this presentation, we will demonstrate SOUL (Smalltalk Open Unification Language), an open, reflective logic programming environment written in Smalltalk VisualWorks 5i4 and ported to various other Smalltalk dialects (such as Squeak). In the first part of the presentation we show how the environment and associated tools can be used in practice to:

  • Reason about object-oriented programs (including naming and programming conventions, design pattern extraction, type inferencing, UML model extraction, architectural views,...)
  • Declaratively generate code (including source code templates, aspect-oriented programming, design pattern code generation, ...)
  • Support software evolution (including refactoring, software merging, ...)

During the second part of the presentation, we take a closer look at the technical details. We show how high-level software artifacts can be expressed in terms of logic facts and rules. For this, we require that the logic meta programming language lives in symbiosis with the object-oriented base language, allowing base level programs to be manipulated as terms, facts or rules in the meta level. In the case of Smalltalk, we use the reflection facilities to implement a logic meta layer on top of the Smalltalk meta-object protocol.


  • Wednesday, June 12, 12:15
  • Friday, June 14, 15:15


D06: Typed Concurrent Objects

Presenters: Vasco T. Vasconcelos, University of Lisboa, Luis Lopes, University of Porto

TyCO stands for "TYped Concurrent Objects". A few basic constructors in the lan-guage provide for a form of concurrent object-based programming (that is, objects but no inheritance), without requiring primitive objects. The language is quite simple: the basic syntax reduces to half-a-dozen constructors, and can be thought of as an assembly language for concurrent, object-based, distributed programming. To help in writing common program-ming patterns, a few derived constructors are available. TyCO is implicitely typed: a type inference system assigns monomorphic types to variables, and (a la ML) polymorphic types to procedures. TyCO provides for a simple model of concurrent object-based programming that combines the benefits of the formal framework of process calculi with the characteristics of Agha and Hewitt's actor systems.
The Virtual Machine runs byte-code generated by a compiler. The compiler, incorporating a type-inference system, gathers static information that is used to generate op-timized code. The design and implementation of the virtual machine focuses on performance, compactness, and architecture independence with a view to mobile computing. The byte code has a simple layout and is a compromise between size and performance. For specially crafted benchmarks, the current implementation performs close or better than languages such as Pict, Oz, and JoCaml.
The TyCO distribution is available at http://www.ncc.up.pt/~lblopes/tyco/, and includes the TyCO compiler (tycoc), the emulator (tyco), example applications, and docu-mentation (tutorial, getting started, language definition).


  • Wednesday, June 12, 14:30
  • Thursday, June 13, 11:30

D07: LAVA -Object-based Dynamic Inheritance for Java


Günter Kniesel, Uwe Bardey,Tobias Windeln and Jörg Gonska, University of Bonn

The traditional notion of inheritance,which dates back to Simula 1967 and Smalltalk 78,has often been criticized as being too rigid to express dynamic evolution of structure and behaviour and too coarse-grained to express object-specific sharing of state and behaviour.A more expressive alternative,object-based dynamic inheritance,also known as delegation,was proposed in 1987 by Henry Liebermann. However,it has not yet made its way into mainstream object-oriented languages on the premise of its assumed inefficiency and incompatibility with static typing.
LAVA.LAVA is an extension of Java that refutes these assumptions.It supports statically type safe delegation and its new implementation shows that the code for dynamic inheritance generated by a compiler does not need to be less efficient than manual encoding of the same functionality.
In LAVA,object-based inheritance can be specified simply by adding the keyword delegatee to a variable declaration,e.g."delegatee FinancialComponent _parent.Objects referenced by such variables are called parents .The effect of inheriting methods and state is achieved by automatically forwarding locallyundefined method and variable accesses to parents.When an applicable method is found in a parent it is executed after binding this to the initial message receiver.This binding of this is the defining characteristic of delegation.It lets methods of delegating objects override methods of their parents,just like subclass methods override superclass methods in class-based languages.
In LAVA,determination of the "inherited"code and of part of the inherited interface can take place at object instantiation time or can be fully dynamic.In the first case we talk about fixed delegation and use the usual Java keyword final to indicate that after initialisation parent objects cannot be exchanged. Fixed delegation is particularly interesting because it can be fully unanticipated -objects instantiated from any class can be used as parents.The implementation of parent classes does not need to be aware of delegation and does not need to include any hooks to enable delegation.So delegation can be used as a mechanism for adaptation of existing objects to unanticipated changes.
LAVA shows that fully dynamic (mutable )delegation has to be anticipated in order to make it compatible with static typing.The main idea is that classes whose subclass instances may be used as dynamically exchangeable parents must be annotated with a keyword that indicates this intended use.
The demo. The session will consist of two parts,a slide-based presentation and a practical demonstration. The presentation will introduce object-based dynamic inheritance,the related language extensions of LAVA and the reasons why they are designed exactly this way.The practical part will show how typical scenarios for representing objects with evolving or context-dependent behaviour (e.g.the wrapper, decorator,state and strategy pattern)can be encoded with minimal effort and how delegation can be used for unanticipated adaptation.The run-time and space costs of the LAVA -based implementations will be compared to implementations of the same functionality in pure Java.


  • Wednesday, June 12, 14:30
  • Thursday, June 13, 14:30


D08: A Threaded Code Interpreter for Rotor, Microsoft's Shared Source Implementation of the Common Language Infrastructure (CLI)

Presenters: Yahya H. Mirza, Aurora Borealis Software

In 1994, as an architect Mr. Mirza provided consulting support for Spatial Technologies on their core ACIS Geometry Libraries and it's integration with COM. Additionally, Mr. Mirza has been researching compositional frameworks since he was a visiting member of Ralph Johnson's Smalltalk Programming Group at the University of Illinois in 1995. Mr. Mirza also consulted for SAFECO Life Insurance during the early phases of design for their distributed intranet architecture. Finally in 1999, Mr. Mirza through his company Aurora Borealis Software was a Software Design Engineer in the Microsoft .NET Web Objects and Messaging Team. Currently Mr. Mirza is conducting component technology research utilizing Microsoft's Shared Source Rotor implementation of the CLI.
Language interoperability and distributed objects are areas that have been of interest for quite some time now. Commercial implementations have varied from a standardized meta-object system based on inheritance, i.e. IBM's SOM, to a binary standard with standard compositional idioms, i.e. Microsoft's COM. With the wide scale adoption of the Java platform, the importance and mind-share of language agnostic solutions was put on the backburners. Recently, Microsoft has introduced their next major evolution of their computing platform, the .NET initiative. The core of this initiative is a language agnostic runtime system, which is being standardized by ECMA. This effort is called the Common Language Infrastructure or the CLI. Finally, the language interoperability and integration solutions promised in the 90's are now becoming a pervasive commercial reality. Furthermore, the multi-vendor adoption of Microsoft's .NET initiative provides a great opportunity for language researchers. This opportunity allows a language researcher to innovate in their particular domain, while interoperating with existing commercial and research oriented language based solutions.
Recently, Microsoft released a "Shared Source" implementation of the CLI available on both BSD UNIX as well as the Windows platform codenamed "Rotor". A key technical advantage of the CLI is the ability of its intermediate language to support multiple language paradigms, as opposed to a single rigid object model. For language designers, Rotor can serve as an effective runtime core for experimentation at the language feature level. For compiler and virtual machine researchers, Rotor provides a context for applied research into alternative object representations, method dispatch, garbage collectors, JIT compilers, etc. My goal is to provide an in depth exploration into Rotor using my threaded code interpreter as an example Rotor extension.
The objective of this demonstration is to enable the language or virtual machine researcher to use the Rotor implementation, as a host environment for their research. Not only will the demonstration attendees learn about the inner workings of the Rotor implementation, they will also learn about alternative design options and their ramifications which led to the current architecture of the CLI. The approach to describing Rotor as well as my threaded code interpreter will be based on identifying the patterns and idioms embodied within Rotor, as well as describing their implementation details. Additionally, I plan to illustrate similarities and differences with other runtime systems including the Squeak and Java virtual machines.


  • Wednesday, June 12, 15:15
  • Thursday, June 13, 15:15


D09: GME: A Reflective Environment for Domain-Specific Modeling

Presenters: Akos Ledeczi, Institute for Software Integrated Systems Vanderbilt University

The Generic Modeling Environment (GME 2000) is a metaprogrammable graphical editor supporting the design, analysis and synthesis of complex, software-intensive systems in diverse engineering fields. It is closely related to such metaCASE tools as MetaEdit+ or Dome. GME 2000 is the result of over a decade long research at Vanderbilt University in model integrated computing. The toolset has been applied to several real world applications throughout the US.
GME 2000 has a component-based architecture using MS COM technology and is implemented in C++. The Core component exposes the domain-specific language specification through a set of COM interfaces. Another set of interfaces for bi-directional model access and also exposes all the model modification events. All the other tool components, (diagram editor, decorators, browser, event-based OCL constraint manager, software generators, etc.) are built independently around the Core. Model persistence is supported via standard database technology and XML import/export functionality. The standard technologies applied throughout the architecture (UML, OCL, COM, XML) make GME 2000 easily applicable and extensible to a wide variety of domains.
After introducing the basic concepts, the demonstration will start by building a domain-specific graphical modeling environment for hierarchical Finite State Machines fromscratch. Then we'll demonstrate the scalability of the approach by focusing on a complex real-world example domain, an integrated simulation framework for embedded systems. We'll show the UML and OCL based metamodels specifying the domain-specific visual modeling language. We'll reveal how the environment supports metamodel composition. We'll demonstrate how the domain-specific environment is generated automatically from the metamodels. We'll emphasize how the target visual modeling language supports such OO concepts as type inheritance and multiple aspects. We'll show an example application, an Automatic Target Recognition system, including its complex models and the automatically generated Matlab simulation and C implementation of it.


  • Thursday, June 13, 16:30
  • Friday, June 14, 14:30

D10: Using the Montages Language Prototyping Tool to add Object-Orientedness to Xasm

Presenters: Philipp W. Kutter, Applied Formal Methods Institute AG and ETH Zurich

We have developed the Montages method and tool for specifying and implementing domain-specific languages. Montages is based on EBNF, Attribute Grammar, finite state machines (FSMs), and a small imperative language called eXtensible Abstract State Machines (Xasm), which is a generalization of Gurevich's Abstract State Machines (ASMs). Imperative features of a described language such as destructive updates and jumps can be modeled in a direct way. Xasm is not only used to give actions associated with states of the FSMs and control-guards associated with the transitions of the FSMs, but as well for giving semantics to Montages and as basis for implementing Montages. The Xasm language itself is specified and implemented using the Montages tools, leading to different possibilities of bootstrapping. In this tool demo we show how the Montages tool is currently used to design the object-oriented version of Xasm and we sketch how the new design is bootstrapped.


  • Wednesday, June 12, 11:30
  • Wednesday, June 12, 16:30


D11: SoftwarePot:Encapsulated File Spaces for Secure Software Circulation

Presenters: Yoshihiro Oyama, Kazuhiko Kato, Japan Science and Technology Corporation, Katsunori Kanda, University of Tsukuba

We will demonstrate our object-oriented system SoftwarePot, which provides a sandboxed execution environment called pot .Pots are different from traditional sandboxes in that each pot contains its own virtual file space. SoftwarePot is useful for preventing malicious or vulnerable software from accessing or damaging real crucial files. Our demonstration will show SoftwarePot running on a PC (Linux/x86).Visitors to our booth can see the execution of widely used programs (e.g. bash, Emacs and GIMP)being confined in a pot. They can also experience operating SoftwarePot by themselves.

Technical Merits:

  • Users can flexibly control programs running in a pot by specifying security policies for controlling socket communication and file mappings between a pot and real files.
  • A file space created in a pot is independent of the real file space. Users can hide a /etc/passwd .file by supplying a fake /etc/passwd file to a pot.
  • Pots can be serialized and transferred; SoftwarePot can create a plain file that represents the snapshot of a pot.The plain .le is transferred between sites as software combined with its execution state.
  • SoftwarePot is a user-level middleware located between applications and operating sys-tems. Executing SoftwarePot does not require a root privilege. In addition, SoftwarePot does not force programs to be written in a specific language.
  • SoftwarePot can create a software package that includes a virtual file space for sandboxing the software; few systems are able to do that.
  • SoftwarePot can encapsulate file spaces by means of a flexible access-control mechanism, which is similar to ones seen in object-oriented systems. There is little research on encapsulating file spaces in an object-oriented manner.

Relevance to Object-Oriented Technology. Object-oriented technologies have had a strong influence on the design of SoftwarePot. SoftwarePot manages software packages in an object-oriented manner. Users can deal with encapsulated file spaces (pots)as objects and files as object members. Some files in a pot are public; they are shared with other pots. Others are private ;they are not accessible from outside the pot. Files in a pot cannot only be mapped to real files but can also be mapped to processes. This feature is similar to the property mechanism in C#.
SoftwarePot web page:http://www.osss.is.tsukuba.ac.jp/pot/


  • Thursday, June 13, 14:30
  • Friday, June 14, 11:30

D12: LES Objects: A Model-based Code Generation Environment for Object-Oriented Conceptual Modeling of Web Application Interfaces

Presenters: Jaime Gómez, Cristina Cachero, Antonio Párraga, Web Engineering Group, University of Alicante

Existing tools intended to build and deploy engaging complex Web sites (including functionality) have shown to be inadequate to face the software production process in an unified and systematic way, from a precise system specification to the corresponding final implementation. In this context, where new technologies are continuously emerging, new approaches are required for the web developer to address the entire software lifecycle, from design to development to deployment to maintenance, in a way that is consistent, efficient and lets developers write language-independent applications.
To address this concern we report the Object-Oriented Hypermedia (OO-H) methodological proposal and their associate precompetive CASE Tool that, using an Object-Oriented approach, captures all the relevant properties involved in the modeling and implementation of Web Application Interfaces. The design process involves the construction of two additional views, complementary to those captured in traditional, UML-compliant, conceptual modeling approaches. These are, namely, the Navigation View, which extends a class diagram with hypermedia navigation features, and the Presentation View, in which the different elements regarding interface appearance and behavior are modeled by a series of interconnected template structures, expressed in XML. As a result, a language-independent front-end specification is obtained. From there a web interface, easily integrable with preexistent logic modules, can be generated in an automated way.
The CASE tool provides an operational environment that supports all the methodological aspects of OO-H Method. It simplifies the design and implementation of web-based Information Systems from an object-oriented perspective, providing a comfortable and friendly interface for elaborating the OO-H Method models. The most interesting contribution of this CASE environment is its ability to generate the web application front-end in well-known industrial software development environments. This CASE Tool is being used at this moment for the resolution of real web applications, in the context of a R&D projects carried out jointly by the Web Engineering Group of the University of Alicante and a set of industrial partners.


  • Wednesday, June 12, 17:15
  • Thursday, June 13, 16:30

D13: Octopus: A PostWIMP Framework for New Interaction Techniques

Presenters: Mads Brøgger Enevoldsen, Michael Lassen, Computer Science Dept., University of Aarhus

The Octopus project integrates advanced interaction techniques based on a novel user interface architecture to support new interaction methods in complex graphical tools. Examples of such tools could be UML editors, state charts, Petri nets, simulations etc.
The system is developed in the object-oriented programming language BETA (http://www.daimi.au.dk/~beta).
Graphics are implemented with the OpenGL graphics library to create visual effects such as transparency and shadows and to take full advantage of the growing capabilities of new strong graphics cards in current and future generations of personal computers. The choice of BETA/OpenGL was made due to the platform independence of these. Also Octopus is a good example of a framework utilizing BETA's powerful abstraction mechanisms including virtual classes and nested classes.
The system supports simultaneous inputs from multiple pointing devices based on the widespread USB standard. This allows for the two-handed interaction forms known from everyday life.
One such use of two-handed input supported by the framework is the use of semi-transparent "tool glasses" controlled by one hand. Through this toolglass actions can be applied to objects on the canvas with the use of the other hand. This is similar to the work form used when holding a nail in one hand and applying a hammer with the other. Other two-handed interactions are: Zooming by stretching and scrolling by panning (i.e. no need for zoom menu and scrollbars).
Another interaction form supported by the framework is the so-called "marking menus". These are context dependant circular shaped menus in which items are selected by dragging the mouse in a direction (as opposed to dragging the mouse a specified distance as known from traditional linear menus). By having integrated a gesture recognition algorithm the user can select a menu item with a quick "stroke" even without waiting for the menu to appear. Measurements have proven up to 40% faster interaction by using this principle.

The demonstration will show applications developed on top of this framework.
One such example is the CPN/Tools application (http://www.daimi.au.dk/CPNtools) for editing and simulating Petri Nets.
We expect to have a version of Octopus ready for free download at the time of the conference.
If time allows, we will also give a short overview of the status of some of the other research projects going on at our institute, e.g.
1. BETA.Eclipse: Integration of BETA in the Eclipse framework (http://www.eclipse.org)
2. BETA.java/BETA.Net: Porting of the BETA language to the Java VM and the Microsoft .NET platform.
3. Mjølner System. Current status of the system used for developing e.g. the Octopus framework.


  • Wednesday, June 12, 15:15
  • Thursday, June 13, 15:15
Technical programme - Demos
Last modified on May 23, 2002
Maintained by webmaster@2002.ecoop.org