Tuesday, 28 October

8:30-10:00

Onward! Free Culture: The limited but essential role of property in building an environment for creativity

10:00-17:00

Poster: Posters on display

10:30-17:00

DesignFest®:

10:30-12:00

Technical Paper: Refactoring and Reflection
Panel: Meeting the Challenge of Software Engineering Education for Working Professionals in the 21st Century
Onward!: Naturalistic Programming and Run-Time Code Generation

11:00-11:45

Demonstration 2: Smart Play-Out
Demonstration 7: Making reusable learning objects available through LOM and XML
Demonstration 10 F-Script: Smalltalk Scripting for the Mac OS X Object System
Demonstration 23: AspectJ Development Tools

12:00-13:30

The ACM SIGPLAN Student Research Competition: Student Research Finalists Presentation

12:00-12:45

Demonstration 4: Automated Impact Analysis of Objected Oriented Software
Demonstration 6: Hardware/Software Codesign For Neo Smalltalk
Demonstration 8 QuickUML: a tool to support iterative design and code development
Demonstration 9: The Generic Modeling Environment

13:30-17:00 Afternoon

Tutorial 21: Feature Oriented Programming and Product-Lines
Tutorial 37: Dungeons and Patterns!
Tutorial 38: Project Retrospectives in Agile Development
Tutorial 39: Enterprise Aspect-Oriented Programming with AspectJ
Tutorial 40: An Overview of UML 2.0
Tutorial 41 C++ Threading: A Generic-Programming Approach
Tutorial 43 Program Generation: Concepts and Techniques
DesignFest®:

13:30-15:00

Keynotes & Invited Speakers: Grid-supported Communications Applications

15:00-15:45

Demonstration 5 JPie: An Environment for Live Software Construction in Java
Demonstration 11 ATCT: a Java Framework that Offers New Approach to Developing Asynchronous Processes
Demonstration 12: Generative Model Transformer
Demonstration 13: Semantic Software Engineering Tools

15:30-17:00

Panel: Xtreme Programming and Agile Coaching
Practitioners Report: Tools

15:30-16:30

Technical Paper: Smalltalkiana

16:00-16:45

Demonstration 14 MetaEdit+: Defining and using domain-specific modeling languages and code generators
Demonstration 15: A Policy Based System to Incorporate Self-Managing Behaviors in Applications
Demonstration 16: Using Events to Debug Java Programs Backwards in Time
Demonstration 26: Time Conscious Objects

17:30-19:30

Special Event: Java Community Process reception, hosted by Sun Microsystems

19:30-22:00

Special Event: eclipse Plug-in Reception, hosted by eclipse

Sunday, 26 October – 8:30-17:00 Full day

Sunday, 26 October – 13:30-17:00 Afternoon

Tuesday, 28 October – 10:30-17:00

Tuesday, 28 October – 13:30-17:00 Afternoon

Posters on display

Monday, 27 October – 17:30-19:30

Tuesday, 28 October – 10:00-17:00

Wednesday, 29 October – 10:00-17:00

Thursday, 30 October – 10:00-14:00

Workshop on Process Engineering for Object-Oriented and Component-Based Development

Brian Henderson-Sellers, University of Technology, Sydney, brian@it.uts.edu.au

The poster will describe the results of the OOPSLA workshop on this topic

Workshop: Second International Workshop on Agent-Oriented Methodologies

Brian Henderson-Sellers, University of Technology, Sydney, brian@it.uts.edu.au

The poster will describe the results of the OOPSLA workshop on this topic

The Twelfth OOPSLA Workshop on behavioral semantics -- Striving for Simplicity

Haim Kilov, Independent Consultant and Stevens Institute of Technology, haimk@acm.org
Kenneth Baclawski, College of Computer Science, Northeastern University, ken@baclawski.com

Elegant OO specifications of business and system semantics

Visualizing Class Interfaces with Concept Lattices

Uri Dekel, ISRI, School of Computer Science, Carnegie Mellon University, udekel@cs.cmu.edu
Yossi Gil, CS Dept, Technion, Israel, yogi@cs.technion.ac.il

Our research promotes the use of a mathematical concept lattice based upon the binary relation of accesses between methods and fields as a novel visualization of individual Java classes. We demonstrate in a detailed real-life case study that such a lattice is valuable for reverse-engineering purposes, in that it helps reason about the interface and structure of the class and find errors in the absence of source code. We also show that this lattice can be of assistance in selecting an efficient reading order for the source code, if available. Our technique can also serve as a heuristic for automatic feature categorization, enabling it to assist efforts of re-documentation.

Time Conscious Objects: A Domain-Specific Framework and Generator

Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com
Jeff Hoare, SoftMetaWare, jeff.hoare@softmetaware.com

Time is a crosscutting concern that is hard to separate from other business logic. We have developed Time Conscious Objects (TCO), a Java toolkit that allows existing business application systems to be extended with "time conscious" behavior by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base.

Middleware Benchmarking: Approaches, Results, Experience

Petr Tuma, Charles University, Czech Republic, petr.tuma@mff.cuni.cz
Paul Brebner, CSIRO, Australia, paul.brebner@csiro.au
Emmanuel Cecchet, INRIA Rhone-Alpes, France, emmanuel.cecchet@inrialpes.fr
Julie Marguerite, INRIA Rhone-Alpes, France, julie.marguerite@inrialpes.fr

The poster presents results of the OOPSLA 2003 Workshop on Middleware Benchmarking. The workshop is a meeting point between developers and users as two groups involved in middleware benchmarking. The poster identifies the obstacles encountered when designing, running and evaluating middleware benchmarks and proposes approaches to tackle these obstacles.

Visualization of Eclipse

Chris Laffra, IBM Ottawa Labs, Chris_Laffra@ca.ibm.com

The Eclipse platform uses plugins and an extension mechanism to manage complexity. This leads to hundreds or even thousands of plugins. Bytecode instrumentation can be used to visualize all these plugins. We show plugin activity and communication, plugin memory usage, detailed method tracing facilities, and custom visualizations.

An Introduction to Fly: A Smaller Smalltalk

Thomas Wrensch, University of the Pacific, Department of Computer Science, twrensch@uop.edu
Jonathan Schifman, University of the Pacific, Department of Computer Science, j_schifman@uop.edu

Fly is a lightweight version of the Smalltalk programming environment. Fly attempts to preserve the benefits of Smalltalk as a development system while making it feasible to develop applications for embedded systems, PDAs, and other limited resource environments. Here we introduce the Fly project and its current and expected results.

Generative Model Transformer: An Open Source MDA Tool Initiative

Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com
Ghica van Emde Boas, Bronstee Software & Services, emdeboas@bronstee.com

The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecture tool. The project should result in (a) a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development, (b) a tool for industrial use, and (c) MDA related research. A distinctive feature of GMT is the emphasis of model transformations as "first-class model citizens".

Dynamic Personal Roles for Ubiquitous Computing

Robert McGrath, Department of Computer Science, University of Illinois at Urbana-Champaign, mcgrath@ncsa.uiuc.edu
Dennis Mickunas, Department of Computer Science, University of Illinois at Urbana-Champaign, mickunas@cs.uiuc.edu

This paper presents doctoral research on a key problem for ubiquitous computing: implementation of representatives for physical objects, particularly people. This poster outlines an approach to implementing dynamic personal roles suitable for a ubiquitous computing environment.

Implications of Test-Driven Development: A Pilot Study

Reid Kaufmann, Sun Microsystems, Inc., reid.kaufmann@sun.com
David Janzen, Bethel College, djanzen@bethelks.edu

A Spring 2003 experiment examines the claims that test-driven development or test-first programming improves software quality and programmer confidence. The results indicate support for these claims and inform larger future experiments.

Agile Software Development for Component Based Software Engineering

Wolfgang Radinger, Vienna University of Technology, Institute of Computer Technology, radinger@ict.tuwien.ac.at
Karl Michael Göschka, Frequentis Nachrichtentechnik GmbH, goeschka@acm.org

Agile Software Development and Component Based Software Engineering are two fundamentally different methods to serve today's demands of software engineering. By combining the technical and organizational issues, we introduce an approach for a consequent integration to allow agile component development in the small and system engineering in the large, respectively.

Dynamically Updatable Component-based System

Robert Bialek, DIKU, University of Copenhagen, bialek@diku.dk

Updating 24/7/365 distributed, component-based applications is challenging. We present a framework of a Dynamically Updatable Component-based System (DUCS) and some of its implementation details. The framework is a multi-layered extension to now-a-days VirtualMachines supporting updates of heterogenous components. Prototype is a distributed GroupWare application build on top of the framework.

MAS: A Multi-Agent System Modeling Language

Viviane Silva, Pontifical Catholic University, viviane@inf.puc-rio.br
Carlos Lucena, Pontifical Catholic University, lucena@inf.puc-rio.br

We propose a multi-agent system modeling language (MAS-ML) that extends UML based on structural and dynamic properties presented in a conceptual framework called TAO (Taming Agents and Objects). The main difference between our approach and the others is the clear definition and representation of the elements that compose multi-agent systems.

*J: A Tool for Dynamic Analysis of Java Programs

Bruno Dufour, McGill University, bdufou1@cs.mcgill.ca
Laurie Hendren, McGill University, hendren@cs.mcgill.ca
Clark Verbrugge, McGill University, clump@cs.mcgill.ca

We describe a complete system for gathering, computing and presenting dynamic metrics from Java programs. The system itself was motivated from our real goals in understanding program behaviour as compiler/runtime developers, and so solves a number of practical and difficult problems related to metric gathering and analysis.

Beyond Green-Field Software Development: Strategies for Reengineering and Evolution

Dennis Mancl, Lucent Technologies, Murray Hill, NJ, mancl@lucent.com
William Opdyke, North Central College, Naperville, IL, opdyke@noctrl.edu
Steven Fraser, Consultant, Santa Clara, CA, sdfraser@acm.org
Willem-Jan van den Heuvel, InfoLab, Tilburg University, Tilburg, The Netherlands, W.J.A.M.vdnHeuvel@uvt.nl

This poster will be a report of the results of the workshop of the same title. The workshop addresses two important situations in the creation and evolution of long-lived software systems: how to renew an old software system and how to manage a software system that demands constant change and growth. In both situations, it is a challenge to manage the evolution process. The workshop will discuss a set of techniques and tools for software evolution that can contribute to success.

Engineering and Reusing Stable Atomic Knowledge (SAK) patterns

Haitham Hamza, University of Nebraska-Lincoln, hhamza@cse.unl.edu
Mohamed Fayad, San José State University, m.fayad@sjsu.edu

Reusing domain-independent knowledge might be hindered if such knowledge is presented as an integral part of domain specific components. This poster presents the concept of Stable Atomic Knowledge (SAK) patterns. A SAK pattern presents a domain-independent knowledge in such a way that makes this knowledge reusable whenever it is needed.

Extracting Domain-Specific and Domain-Independent Patterns

Haitham Hamza, University of Nebraska-Lincoln, hhamza@cse.unl.edu
Ahmed Mahdy, University of Nebraska-Lincoln, amahdy@cse.unl.edu
Mohamed Fayad, San José State University, m.fayad@sjsu.edu
Marshall Cline, MT Systems Co., cline@ parashift.com

There are no mature guidelines or methodologies exist for extracting patterns. Software Stability Model can provide a base for extracting patterns. This poster presents the concept of extracting both domain-specific and domain- independent patterns from systems that are built using software stability concepts.

An Approach to Monitor Application States for Self-Managing (Autonomic) Systems

Hoi Chan, IBM T.J Watson Research Center, IBM Corp., hychan@us.ibm.com
Trieu Chieu, IBM T.J Watson Research Center, IBM Corp., tchieu@us.ibm.com

Monitoring the states of an application is an important part of building applications with self-managing behaviors. The problem lies on those applications where no source code is available to add monitoring functions, or modification is expensive. In this report, we will describe an Aspect Oriented Programming based approach to build generic monitoring systems for legacy applications

The "Killer Examples" for Design Patterns and Objects First workshops held at OOPSLA 2002 and 2003

Carl Alphonce, University at Buffalo, SUNY, alphonce@cse.buffalo.edu
Stephen Wong, Rice University, swong@cs.rice.edu
Dung Nguyen, Rice University, dxnguyen@cs.rice.edu
Phil Ventura, University at Buffalo, SUNY, pventura@cse.buffalo.edu
Michael Wick, University of Wisconsin - Eau Claire, wickmr@uwec.edu

A killer app is an "application that actually makes a sustaining market for a promising but under-utilized technology." [The Jargon File] A "killer example" provides clear and compelling motivation for some concept. This poster reports on OOPSLA2002 and OOPSLA2003 workshops exploring "killer examples" for teaching design patterns and objects-first.

Patterns in Retrospectives

Linda Rising, Independent consultant, risingl@acm.org
Mary Lynn Manns, University of North Carolina at Asheville, manns@unca.edu

Retrospectives are important, not only for object technology, but for any human activity. Our workshop will begin documenting patterns for retrospectives and proposing an initial pattern language structure. The poster will present the skeleton outline of the fledgling pattern language and the patterns that will have been presented.

Model Driven Architecture Development Approach for Pervasive Computing

Kai Hemme-Unger, DaimlerChrysler, kai.hemme-unger@web.de
Thomas Flor, DaimlerChrysler, thomas.flor@daimlerchrysler.com
Walter Niess, DaimlerChrysler, walter.niess@daimlerchrysler.com
Gabriel Vögler, DaimlerChrysler, gabriel.voegler@daimlerchrysler.com

The evaluation of a model driven architecture development approach on the project derived from the need to shorten the time-to-market and to improve the software quality. This seems to be reachable by applying application knowledge ex post to afore implemented building blocks.

A Framework to Enable User Directed Component Binding at Run-Time

Timothy Troup, University of Glasgow, troup@dcs.gla.ac.uk
Iain Darroch, University of Glasgow, darrochi@dcs.gla.ac.uk

Currently experimental scientists must perform time consuming and error-prone tasks to drive a series of computational data analyses. We have designed and implemented a novel framework that obviates the need for these tasks to be performed by enabling user directed component binding at run-time.

Using Language Interpreters as Tools for Learning Different Programming Paradigms

Arlindo da Conceicao, University of São Paulo, Brazil, arlindo@ime.usp.br
Edson Sussumu, University of São Paulo, Brazil, susumu@ime.usp.br
Ariane Lima, University of São Paulo, Brazil, ariane@ime.usp.br
Marcelo Brito, University of São Paulo, Brazil, mbrito@ime.usp.br
Jorge Del Teglia, University of São Paulo, Brazil, jorge@linux.ime.usp.br

We present a framework for implementing educational language interpreters. The architecture of the system was planned to highlight paradigm similarities and differences and also to offer clean object-oriented design. The framework includes classes to implement the functional (including closures and delayed evaluation), object-oriented, and logic programming paradigms.

The Third OOPSLA Workshop on Domain-Specific Modeling

Jeff Gray, University of Alabama at Birmingham (UAB), gray@cis.uab.edu
Matti Rossi, Helsinki School of Economics, mrossi@hkkk.fi
Juha-Pekka Tolvanen, MetaCase Consulting, jpt@metacase.com

This poster describes a framework for implementing domain-specific visual modeling languages and summarizes industrial experiences from the use of domain-specific languages. The results of the Third OOPSLA Workshop on Domain-Specific Modeling will also be reported in this poster.

Teaching Software Testing: Automatic Grading Meets Test-First Coding

Stephen Edwards, Virginia Tech, Dept. of Computer Science, edwards@cs.vt.edu

A new approach to teaching software testing is proposed: students use test-driven development on programming assignments, and an automated grading tool assesses their testing performance and provides feedback. The basics of the approach, screenshots of the system, and a discussion of industrial tool use for grading Java programs are discussed.

Modular Quality of Service-enabled Management Service for Component-based Distributed Systems

Octavian Ciuhandu, Performance Engineering Laboratory, ciuhandu@eeng.dcu.ie
John Murphy, Performance Engineering Laboratory, murphyj@eeng.dcu.ie

We present a modular QoS-enabled load management framework for component oriented middleware. It offers the possibility of selecting the optimal load distribution algorithms and changing the load metrics at runtime. The QoS service level agreements are made at user level, transparent to the managed application. According to the complexity of the managed application, only some of the modules might be required, thus activated.

An AspectJ-Enabled Eclipse Core Runtime

Martin Lippert, University of Hamburg & it-Workplace Solutions Ltd., lippert@acm.org

The poster shows the ideas and techniques behind a combination of the world of Eclipse plugins and AspectJ, for example implementing logging as a separated plugin. Load-time weaving techniques integrated into the Eclipse runtime allow the development of aspects that modularize crosscutting concerns across plugin boundaries.

MRI Visual Analyzer: a comparative study of different analysis and design modeling methods

Elham Yavari, Graduate student, College of Engineering, San José State University, e_yavari@yahoo.com
Mohamed Fayad, Professor of Computer Engineering, College of Engineering, San José State University, mfayad@sjsu.edu

In order to show the importance of analysis and design methods, we chose a problem statement (MRI visual analyzer) and developed two class diagrams based: traditional OO and software stability methods (SSM). Qualitative comparison between the two model shows that SSM improves the model simplicity, completeness and stability.

A Proposed Framework for the Provision of e-Learning in Programming

Marie-Helene Ng Cheong Vee, Birkbeck College, University of London, gngch01@dcs.bbk.ac.uk

We present a proposed framework for the provision of e-learning in programming and teaching programming irrespective of paradigm and language. The framework, consisting of set of integrated components provides course management, collaborative learning, an Intelligent Tutoring System, and computer-assisted creation of re-usable Learning Objects - all in the context of the Inverse Curriculum.

Metamodeling Approach to Model Transformations

Sheena Judson, Louisiana State University, sheena.judson@att.net
Doris Carver, Louisiana State University, carver@csc.lsu.edu
Robert France, Colorado State University, france@cs.colostate.edu

Model Driven Architecture (MDA), which supports the development of software-intensive systems through the transformation of models to executable components and applications, requires a standard way to express transformations. This poster describes an approach based on rigorous modeling of well-defined pattern-based model transformations at the metamodel level.

Multicodes: Optimizing Virtual Machines using Bytecode Sequences

Ben Stephenson, The University of Western Ontario, ben@csd.uwo.ca
Wade Holst, The University of Western Ontario, wade@csd.uwo.ca

A virtual machine optimization technique that makes use of bytecode sequences is introduced. The process of determining candidate sequences is discussed and performance gains achieved when applied to a Java interpreter are presented. The suitability of this optimization for JVMs that perform just-in-time compilation is also discussed.

Distributed Object Inheritance to Structure Distributed Applications

Jessie Dedecker, Vrije Universiteit Brussel, jededeck@vub.ac.be
Thomas Cleenewerck, Vrije Universiteit Brussel, tcleenew@vub.ac.be
Wolfgang De Meuter, Vrije Universiteit Brussel, wdmeuter@vub.ac.be

Prototype-based languages (PBLs) are good at sharing information between objects, while sharing is a ubiquitous problem in distributed application programming (due to concurrency and partial failures). New language concepts can exploit the advantages of PBLs to ease the distribution problems and help express distributed communication patterns.

Free Culture: The limited but essential role of property in building an environment for creativity

Tuesday, 28 October – 8:30-10:00

Larry Lessig, Stanford University, lessig@pobox.com

This talk will sketch the boundaries of protection that intellectual property law should set, but argue that extremism has now defeated these limits. The consequence is an environment within which modular creativity is increasingly constrained.

Presenter

Lawrence Lessig is a Professor of Law at Stanford Law School and founder of the school's Center for Internet and Society. He is one of the country's leading commentators on legal aspects of new communications technologies and cyberspace. He is Professor of Law and founder and executive director of the Center for Internet and Society at Stanford Law School. Professor Lessig teaches and writes in the areas of constitutional law, law and high technology, Internet regulation, comparative constitutional law, and the law of cyberspace.

He is the author of many influential publications about cyberlaw and cyberspace, including two books: The Future of Ideas: The Fate of the Commons in a Connected World (2001) and Code and Other Laws of Cyberspace (1999).

Refactoring and Reflection

Tuesday, 28 October – 10:30-12:00

10:30 - 11:00
Language-Independent Aspect-Oriented Programming

Donal Lafferty, Trinity College Dublin, Donal.Lafferty@cs.tcd.ie
Vinny Cahill, Trinity College Dublin, Vinny.Cahill@cs.tcd.ie

The term aspect-oriented programming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns. Since crosscutting concerns cannot be properly modularized within object-oriented programming (OOP), they are expressed as aspects and are composed, or woven, with traditionally encapsulated functionality referred to as components.

Many AOP models exist, but their implementations are typically coupled with a single language. To allow weaving of existing components with aspects written in the language of choice, AOP requires a language-independent tool.

This paper presents Weave.NET, a load-time weaver that allows aspects and components to be written in a variety of languages and freely intermixed. Weave.NET relies on XML to specify aspect bindings and ECMA Common Language Infrastructure to avoid coupling aspects or components with a particular language.

By demonstrating language-independence, Weave.NET provides a migration path to the AOP paradigm by preserving existing developer knowledge, tools and software components. The tool's capabilities are demonstrated with logging aspects written with and applied to Visual Basic and C# components.

11:00 - 11:30
Refactoring for Generalization Using Type Constraints

Frank Tip, IBM T.J. Watson Research Center, tip@watson.ibm.com
Adam Kiezun, IBM Research OTI Labs, adam_kiezun@ch.ibm.com
Dirk Baeumer, IBM Research OTI Labs, dirk_baeumer@ch.ibm.com

Refactoring is the process of applying behavior-preserving transformations (called "refactorings") in order to improve a program's design. Associated with a refactoring is a set of preconditions that must be satisfied to guarantee that program behavior is preserved, and a set of source code modifications. An important category of refactorings is concerned with generalization (e.g., "Extract Interface" for re-routing the access to a class via a newly created interface, and "Pull Up Members" for moving members into a superclass). For these refactorings, both the preconditions and the set of allowable source code modifications depend on interprocedural relationships between types of variables. We present an approach in which type constraints are used to verify the preconditions and to determine the allowable source code modifications for a number of generalization-related refactorings. This work is implemented in the standard distribution of Eclipse (see www.eclipse.org).

11:30 - 12:00
Partial Behavioral Reflection: Spatial and Temporal Selection of Reification

Eric Tanter, University of Chile, École des Mines de Nantes/INRIA, Eric.Tanter@emn.fr
Jacques Noyé, École des Mines de Nantes/INRIA, Jacques.Noye@emn.fr
Denis Caromel, Université de Nice, Denis.Caromel@inria.fr
Pierre Cointe, École des Mines de Nantes/INRIA, Pierre.Cointe@emn.fr

Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more efficient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection. In the context of Java, we present a reflective architecture offering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection, along with static optimizations. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic aspect-oriented programming.

Meeting the Challenge of Software Engineering Education for Working Professionals in the 21st Century

Tuesday, 28 October – 10:30-12:00

Steven Fraser (Chair), Independent Consultant, sdfraser@acm.org
Ray Bareiss, CMU (West), bareiss@cs.cmu.edu
Barry Boehm, USC, boehm@cse.usc.edu
Mark Hayes, Microsoft, mahayes@microsoft.com
Laura Hill, Sun Microsystems, laura.hill@sun.com
Gabby Silberman, IBM, gabbys@us.ibm.com
Dave Thomas, Bedarra Research Labs, dave@bedarra.com

Software engineering education for working professionals remains a challenge from the perspective of determining relevant content; identifying effective methods for delivery; and maintaining the focus and motivation of students. This panel brings together academic and industry professionals to share their perspectives and experiences. Anticipated points for discussion include: education/training delivery strategies, curriculum definition, marketing issues, collaboration strategies to engage industry sponsorship, value assessments for students and sponsoring organizations, and program success stories. This will be a highly interactive panel and the audience should come prepared to both ask and answer questions.

Naturalistic Programming and Run-Time Code Generation

Tuesday, 28 October – 10:30-12:00

These papers explore simplifying programming by examining some of our underlying assumptions about references and constructing programs.

Beyond AOP: Toward Naturalistic Programming

Cristina Lopes, University of California, Irvine, lopes@ics.uci.edu
Paul Dourish, University of California, Irvine, jpd@ics.uci.edu
David Lorenz, Northeastern University, lorenz@ccs.neu.edu
Karl Lieberherr, Northeastern University, lieber@ccs.neu.edu

Software understanding (for documentation, maintenance or evolution) is one of the longest-standing problems in Computer Science. The use of bct-oriented languages helps, but fundamentally remains far from solving the problem. Most programming languages and systems have fallen prey to the assumption that they are supposed to capture idealized models of computation inspired by deceptively simple metaphors such as objects and mathematical functions. Aspect-oriented programming languages have made a significant breakthrough by noticing that, in many situations, humans think and describe in crosscutting terms. In this paper we suggest that the next breakthrough would require looking even closer to the way humans have been thinking and describing complex systems for thousand of years using natural languages. While natural languages themselves are not appropriate for programming, they contain a number of elements that make descriptions concise, effective and understandable. In particular, natural languages referentiality is a key factor in supporting powerful program organizations that can be more easily understood by humans.

Routine Run-time Code Generation

Sam Kamin, Univ. of Illinois at Urbana-Champaign, kamin@cs.uiuc.edu

The decades-old paradigm of "object code = executable code: is outdated. The paradigm we propose in this paper is "object code = executable program generator.: Similarly, "software component" should be "program that, when appropriately invoked by a client, generates machine language useful to the client." Traditional object files amount to constant functions in the domain of code-producing functions; in the future, we will routinely employ the full domain of higher-order code values. In this paper, we argue that such a change in viewpoint can lead to much wider use of run-time code generation, by overcoming the bureaucratic barriers it usually encounters. Run-time code generation has numerous applications; when it comes to be used routinely, many more applications are likely to be discovered.

2 Smart Play-Out

Tuesday, 28 October – 11:00-11:45

Wednesday, 29 October – 12:00-12:45

David Harel, Weizmann Institute of Science, dharel@wisdom.weizmann.ac.il
Hillel Kugler, Weizmann Institute of Science, kugler@wisdom.weizmann.ac.il
Rami Marelly, Weizmann Institute of Science, rami@wisdom.weizmann.ac.il
Amir Pnueli, Weizmann Institute of Science, amir@wisdom.weizmann.ac.il

This demo shows Smart Play-Out, a new method for executing and analyzing scenario based behavior, which is part of the Play-In/Play-Out methodology and the Play-Engine tool. Behavior is "played in" directly from the system's GUI, and as this is being done the play-engine continuously constructs Live Sequence Charts (LSCs), a powerful extension of sequence diagrams. Later behavior can be "played out" freely from the GUI, and the tool executes the LSCs directly, thus driving the system's behavior.

Smart Play-Out, a recent strengthening of the play-out mechanism, uses verification methods, mainly model-checking, to execute and analyze the LSCs, helping the execution to avoid deadlocks and violations. Thus, Smart Play-Out utilizes verification techniques to run programs, rather than to verify them.

Our approach is especially useful for specifying reactive object-oriented systems, and the LSC language we use has been extended to distinguish between objects and classes and to allow specifying of symbolic scenarios that hold for all object instances of a certain class.

In the demo we will show and explain the tool, illustrating the approach on several applications we have studied, including a phone network, a machine for manufacturing smart-cards and a model of a biological system.

As a long-term goal, for certain kinds of systems the play-out methodology, enhanced by formal verification techniques, could serve as the final implementation too, with the play-out being all that is needed for running the system itself.

7 Making reusable learning objects available through LOM and XML

Tuesday, 28 October – 11:00-11:45

Thursday, 30 October – 12:00-12:45

Lars Arne Skar, Implementation lead/System architect, lars@bekk.no
Thomas Heiberg, Portal developer/system integrator, thomas.heiberg@bekk.no
Vidar Kongsli, Content developer/integrator, vidar.kongsli@bekk.no

The norwegian ministry of education and research is currently establishing an education portal as part of the national learning net for the education sector. One major goal of this initiative is to enable better reuse and sharing of learning objects on the internet. The portal is developed by BEKK, a Norwegian consultancy.

The demonstration will show:

  • An efficient and user friendly search interface optimised for learning resources
  • Using the LOM standard to facilitate data integration
  • Using loose coupling and XML to enable integration

The LOM (Learning Object Metadata) standard; IEEE 1484.12.1 (http://ltsc.ieee.org/wg12/) standard was approved December 10, 2002 and defines a meta-model to categorize and describe learning objects. Although well received, and internationally recognized, adoption is still in its early stages, which again required the project to define the actual use of the standard in collaboration with local standardization bodies.

The following technologies and products developed the portal and search interface:

  • A portal framework; IBM Websphere Portal Server for the search user interface
  • A search engine; Verity, to index the meta-data for learning objects
  • XML and XML Schema for data interchange and validation

The demo will run on a standard web-browser; although designed to support all browsers; it is optimzed for a javascript enabled browser. The data interchange and internal processes can be displayed by a terminal emulator with SSH support, such as putty.

10 F-Script: Smalltalk Scripting for the Mac OS X Object System

Tuesday, 28 October – 11:00-11:45

Philippe Mougin, -, pmougin@acm.org

F-Script is a new scripting language based on Smalltalk and 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 interactively exploring, testing and using Cocoa-based objects and frameworks. As a Smalltalk dialect, F-Script provides a pure object-oriented environment that leverage Mac OS X technologies. It introduces significant innovations including a high-level model for object manipulation and a graphical object browser.

This demonstration will cover:

  • The F-Script interactive environment.
  • The OOPAL model, a new high level programming model which unify OOP and APL-like Array programming.
  • An innovative graphical object browser (aka. "Behavioral inspector") which supports interactive method invocation.
  • 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 applications with F-Script.

F-Script is an open-source project sponsored by the European Smalltalk User Group and SQLI.

Keywords: Smalltalk, Array programming, F-Script, OOPAL, APL, Scripting Language, Mac OS X, Cocoa.

23 AspectJ Development Tools

Tuesday, 28 October – 11:00-11:45

Wednesday, 29 October – 12:00-12:45

Mik Kersten, University of British Columbia, beatmik@acm.org

AspectJ™ is a seamless aspect-oriented programming extension to Java™. It can be used to cleanly modularize the crosscutting structure of concerns such as exception handling, multi-object protocols, synchronization, performance optimizations, and resource sharing. When implemented in a non-aspect-oriented fashion, the code for these concerns typically becomes spread out across entire programs. AspectJ controls such code-tangling and makes the underlying concerns more apparent, making programs easier to develop and maintain.

The updated AspectJ development tools suite and Eclipse plug-in will be used to demonstrate new tool features including incremental building, bytecode weaving, crosscutting structure views, and debugger support. Some common crosscutting concerns of an existing object-oriented system will be mined and refactored into a modular aspect-oriented implementation. The integration of AspectJ into existing development processes will also be reviewed along with JBuilder®, NetBeans, Emacs, and command-line tool support. Installation of the tools and project setup will demonstrate how easily AspectJ can be applied to existing Java systems.

Student Research Finalists Presentation

Tuesday, 28 October – 12:00-13:30

4 Automated Impact Analysis of Objected Oriented Software

Tuesday, 28 October – 12:00-12:45

Wednesday, 29 October – 15:00-15:45

Michael Hoffman, California State University Long Beach, hoffman@cecs.csulb.edu

Comparative Impact Analysis (CIA) and Predictive Impact Analysis (PIA) are two methods of determining change/modification impact analysis on object-oriented software systems. JFlex, an object- oriented software tool, implements CIA and PIA for Java systems. With JFlex, software maintainers gain immediate knowledge of complex relationships in Java systems such as inheritance and aggregation by using the Extended Low-Level Software Architecture (ELLSA) model. The ELLSA model is built by examining the Java system’s source code. The demonstration will show how JFlex allows maintainers to create the ELLSA of a Java system, perform maintenance activities on the system, and then create a second ELLSA of the system and compare this to the first in order to determine changed components and ripple effect impacts resulting from the maintenance activities (CIA). The demonstration will also show how JFlex can be used to predict ripple effect impacts on an unmodified Java system by creating the ELLSA for the system and allowing the maintainer to ask “what if” questions pertaining to possible changes to the Java system. The resulting analysis helps maintainers to determine testing requirements and which other components must be changed as a result of the proposed modifications. JFlex is implemented in C++ under Microsoft Windows using MFC to construct the GUI. Keywords Object-Oriented Impact Analysis Object-Oriented Maintenance Object-Oriented Software Architecture

6 Hardware/Software Codesign For Neo Smalltalk

Tuesday, 28 October – 12:00-12:45

Wednesday, 29 October – 16:00-16:45

Jecel Assumpção Jr., Merlintec Computadores Ltda., jecel@merlintec.com

The processors normally used for low cost or embedded applications are not well suited for running Smalltalk, so we created our own using programmable circuits (FPGAs). By creating the software and hardware specifically to work with each other it was possible to simplify both to such a degree that the resulting system is competitive in terms of price/performance compared to solutions with traditional processors, despite the inefficiency of FPGAs relative to custom designs. Both a 16 bit and a 32 bit hardware implementation of Neo Smalltalk will be shown in order to illustrate the cost and performance tradeoffs possible in this kind of development. The hardware is defined in terms of objects exchanging messages down to the lowest level, which is an interesting contrast to the traditional bytecoded virtual machines used for Smalltalk, Java and similar languages. Since the programming environment was designed to graphically show all implementation details, the audience will be able to see the issues mentioned above during a demonstration of the normal operation of the two Neo Smalltalk machines.

8 QuickUML: a tool to support iterative design and code development

Tuesday, 28 October – 12:00-12:45

Wednesday, 29 October – 16:00-16:45

Carl Alphonce, Dept. of Computer Science & Engineering, University at Buffalo, SUNY, alphonce@cse.buffalo.edu
Phil Ventura, Dept. of Computer Science & Engineering, University at Buffalo, SUNY, pventura@cse.buffalo.edu

We demonstrate QuickUML, a freely available tool which supports iterative design and code development by providing facilities to draw UML class diagrams, to generate Java code from such diagrams, and also to automatically generate a UML class diagram from a collection of Java source code files.

We developed the tool for use by students in our introductory object-oriented courses. We found existing tools inappropriate due to slow graphics and complex user interfaces. QuickUML is now used in several courses from freshman to senior level.

The demonstration will show QuickUML's various features, including how to draw diagrams, how to generate code from diagrams and how to generate a diagram Java source code. The ability to move between source code and diagrams facilitates the use of an iterative design-and-code software development process.

Our experience is that when students have a tool which allows them to easily express their designs at a high level and frees them from the tedium of repeatedly coding fundamental relationships they begin to think of coding in terms of the higher-level constructs. This in turn allows us to focus more on issues of object-oriented design and less on issues of syntax.

Educators or trainers teaching or using object-orientation in their courses can use QuickUML to support iterative design-and-code development.

9 The Generic Modeling Environment

Tuesday, 28 October – 12:00-12:45

Wednesday, 29 October – 16:00-16:45

James Davis, Research Scientist, Institute for Software Integrated Systems, Vanderbilt University, james.davis@vanderbilt.edu

The Generic Modeling Environment (GME) is a metaprogrammable, domain specific, graphical editor supporting the design, analysis and synthesis of complex, software-intensive systems. It is closely related to metaCASE tools such as MetaEdit+ or Dome. Over a decade of research in model integrated computing has led to the development of GME. The toolset has been applied to modeling and synthesizing several real world applications for both government and industry organizations.

GME has an architecture based on MS COM technology and is implemented in C++. The Core component exposes the domain-specific language specification through a set of COM interfaces. It has another set of interfaces for model access. All the other components, (GUI, browser, OCL constraint manager, software generators, etc.) are built independently around the Core. Model persistence is supported via standard database technology and XML persistence. The technologies applied throughout GME (UML, OCL, COM, XML) make it easily applicable and extensible.

The demonstration will focus on using GME to develop an integrated simulation framework for embedded systems. The UML and OCL based metamodels specifying the domain-specific visual modeling language will be examined. We'll demonstrate how the domain-specific environment is automatically generated from these metamodels. We'll emphasize how the target visual language supports such OO concepts as type inheritance and multiple aspects. The automatic extension of the model access interface will be shown. This interface makes extensive use of OO techniques such as inheritance. We'll show an example application, including its complex models and the automatically synthesized simulation and C code.

21 Feature Oriented Programming and Product-Lines

Tuesday, 28 October – 13:30-17:00 Afternoon

Don Batory, University of Texas at Austin, dsb@cs.utexas.edu

Feature-Oriented Programming (FOP) is both a design methodology and supporting tools for program synthesis. The goal is to specify a target program in terms of the features that it offers, and to synthesize an efficient program that meets these specifications. FOP has been used successfully to develop product lines in widely varying real-world domains, including compilers for extensible Java dialects, fire support simulators for the U.S. Army, network protocols, and program verification tools.

AHEAD is a simple mathematical model of FOP that is based on step-wise refinement, a methodology for building programs by adding one feature at a time. The incremental units of implementation/design are refinements that encapsulate the implementation of an individual feature. AHEAD models of product lines treat base programs as constants and program refinements as functions (that add a specified feature to the input program). Application designs are thus equations--compositions of functions and constants--that are amenable to optimization and analysis.

This tutorial reviews basic results on FOP, including general models and tools for synthesizing a consistent set of code and non-code artifacts by composing refinements (cross-cuts), automatic algorithms for validating refinement compositions, synthesizing product-lines of product-families (e.g., tool suites), and automatic algorithms for optimizing application designs (equations).

Attendee background

Prerequisites: Participants should understand basic concepts of object orientation, but no other special background is necessary.

Format

Lecture

Presenter

Don Batory holds the David Bruton Centennial Professorship at The University of Texas at Austin. He received a B.S. (1975) and M.Sc. (1977) degrees from Case Institute of Technology, and a Ph.D. (1980) from the University of Toronto. He was a faculty member at the University of Florida in 1981 before he joined the Department of Computer Sciences at the University of Texas in 1983.

He was an Associate Editor of IEEE Transactions on Software Engineering (1999-2002), Associate Editor of ACM Transactions on Database Systems (1986-1992), a member of the ACM Software Systems Award Committee (1989-1993; Committee Chairman in 1992), Program Co-Chair for the 2002 Generative Programming and Component Engineering Conference, the Program Chair for the 1995 International Conference on Software Reuse, and the 1999 Workshop on Software Reuse. He has given numerous lectures and tutorials on product-line architectures, generators, and reuse, and is an industry consultant on product lines.

37 Dungeons and Patterns!

Tuesday, 28 October – 13:30-17:00 Afternoon

Steve Metsker, Reader, Thinker, and Writer, Steve.Metsker@acm.org
William Wake, Independent Consultant, William.Wake@acm.org

"Dungeons and Patterns!" is a hands-on tutorial for exploring and learning about design patterns. You can become a more powerful object-oriented developer by learning about these things called "design patterns." The "Design Patterns" book (by Gamma, Helm, Johnson, and Vlissides) explains what patterns are and introduces many of the most useful patterns, but many people find it difficult to learn by reading, and almost everyone improves through practice. The "Dungeons and Patterns!" tutorial lets you research, discover, learn, and explain patterns all at once, in a playful setting that is energizing and motivating while at the same time relaxed and fun.

In "Dungeons and Patterns!" you will encounter dungeon devices, creatures, and settings that serve as metaphors for design patterns. Your mission with your table-mates is to discover these metaphors, determine which pattern is at play, and explain the pattern to an Ahobbit that will accompany your party. The amazing thing about Ahobbits is that whenever they gain enlightenment about patterns (and utter "Ah Ha!"), their epiphanies magically cause further doorways and passages to open, letting you delve deeper and deeper into the patterns dungeon.

In a few hours of play you will become familiar with many patterns -- familiar enough to explain them to someone else!

Attendee background

Prerequisites: Attendees should have at least a little knowledge of design patterns, specifically those in the book "Design Patterns." Experience with role-playing games is a plus, but not necessary.

Format

Role-playing game

Presenters

Steve Metsker is a researcher and author who explores and writes about ways to expand the abilities of developers. Steve is the author of "Building Parsers in Java," the "Design Patterns Java Workbook," and the forthcoming "Design Patterns C# Workbook."

William Wake is an independent consultant and coach. He's the inventor of the XP Programmer's Cube, and the author of "Extreme Programming Explored" and the "Refactoring Workbook."

38 Project Retrospectives in Agile Development

Tuesday, 28 October – 13:30-17:00 Afternoon

Linda Rising, independent consultant, risingl@acm.org
Mary Lynn Manns, University of North Carolina at Asheville, manns@unca.edu

The Principles Behind the Agile Manifesto state that, "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." How should that be done? This tutorial will present techniques for project retrospectives that allow teams to discover what they're doing well so that successful practices can be repeated and identify what should be done differently so that teams can improve. Retrospectives are not "finger pointing" sessions, but rather a highly effective series of activities in which teams can reflect on the past in order to become more effective in the future. Participants will be introduced to the retrospective process, learn techniques for leading retrospectives, hear the experiences of the tutorial leaders who have led retrospectives in various kinds of projects, and participate in a retrospective simulation.

Attendee background

Prerequisites: Participants should have been part of at least one development experience.

Format

Introductory lecture and simulated retrospective

Presenters

Linda Rising has a Ph.D. from Arizona State University in the area of object-based design metrics. Her background includes university teaching experience as well as work in industry in the areas of telecommunications, avionics, and strategic weapons systems. She has been working with object technologies since 1983. She is the editor of "A Patterns Handbook," "The Pattern Almanac 2000," and "Design Patterns in Communication Systems." She has experience leading retrospectives in a number of companies and academic settings around the world, as well as giving presentations on the benefits of retrospectives. She has over 20 years of academic teaching experience and over 15 years of industrial training experience.

Mary Lynn Manns has a Ph.D. from DeMontfort University in England in the area of software patterns. She is on the faculty at the University of North Carolina at Asheville. She has taught seminars on project retrospectives and has led numerous retrospectives in both industry and academia.

39 Enterprise Aspect-Oriented Programming with AspectJ

Tuesday, 28 October – 13:30-17:00 Afternoon

Ron Bodkin, New Aspects of Security, rbodkin@newaspects.com
Adrian Colyer, IBM UK, adrian_colyer@uk.ibm.com

This tutorial teaches participants how to apply AspectJ to enterprise application development using J2EE. It demonstrates some of the more advanced capabilities of AspectJ and how they can be used to address concerns such as security, caching, logging with Jakarta Commons, testing with JUnit, and more. The tutorial is based on a J2EE setting working with servlets, JSPs, EJBs and Web Services. It also compares AspectJ to AspectWerkz and JBoss AOP.

Attendee background

Prerequisites: Attendees should have experience doing object-oriented design and implementation for IT applications. Attendees should have already experimented with AspectJ.

Format

Lectures and hands-on exercises

Presenters

Ron Bodkin is the founder of New Aspects of Security, which extends AspectJ to provide security and privacy management for enterprise applications, and provides consulting on AOP and architecture. Previously, Ron worked for Xerox PARC, where he led the first AspectJ training and implementation projects for customers. Prior to that, Ron was a founder and the CTO of C-bridge, a consultancy that built and customized enterprise applications using Java, XML, and other Internet technologies.

Adrian Colyer is an IBM UK Technical Staff Member with over 10 years of experience in developing enterprise middleware. He leads the open source AspectJ Development Tools for Eclipse project, and is also a committer on the core AspectJ compiler project.

40 An Overview of UML 2.0

Tuesday, 28 October – 13:30-17:00 Afternoon

Bran Selic, IBM Software Group - Rational Software, bselic@rational.com

This tutorial covers the salient aspects of the first major revision of the Unified Modeling Language, UML 2.0. It includes background information on what drove the requirements and the design rationale--from the point of view of one of its primary designers. The overall structure of UML 2.0 is described followed by a more detailed description of the most prominent new modeling features illustrated with many examples. The capacity of UML 2.0 to cover the needs of model-driven development methods is also described.

Attendee background

Prerequisites: Attendees must have practical experience in applying object-oriented technologies in general, and the Unified Modeling Language in particular.

Format

Lecture

Presenter

Bran Selic works for the Rational Software Group of IBM. He is also an adjunct professor of computer science at Carleton University. He has over 30 years of experience in industry in the design and development of large real-time systems. He is the principal author of a book that pioneered the application of object technology and model-driven development methods in real-time applications. From 1996 onwards, he has participated in the definition of the UML standard and its standard real-time UML profile. He is co-chair of a submission team that defined the first major revision of UML, UML 2.0.

41 C++ Threading: A Generic-Programming Approach

Tuesday, 28 October – 13:30-17:00 Afternoon

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

A lot has been written about multithreading, C++, and multithreading in C++. A number of different higher-level threading APIs have been proposed. Some are influenced by object models that are not necessarily appropriate to C++'s own idioms, and some suffer from looking too obviously like C API wrappers, in spite of their specific goal of API independence. In many cases, the resulting object model is less expressive, although far simpler and safer to use, than the underlying API.

This tutorial presents a refined model for threading in C++. The model is simple, idiomatic, and generic, and its thinking is more obviously unchained from the view of thread objects as C API wrappers. It entails a generic-programming approach that is more than simply using templates: it is orthogonal and open. Elements of the resulting thread programming model can also be realized in other programming languages.

Attendee background

Prerequisites: Attendees should be experienced with C++ programming and should have some experience using templates, preferably based on the STL. At least basic familiarity with concurrency concepts is also required.

Format

Lecture

Presenter

Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, OO, CBD, UML, patterns, and software architecture. He is a regular columnist for C/C++ Users Journal (online), Application Development Advisor (UK), and JavaSpektrum (Germany), and previously wrote columns in Java Report and C++ Report. He is also a member of the advisory board for Hillside Europe, the program chair for EuroPLoP 2003, and a popular speaker at conferences in the US and Europe.

43 Program Generation: Concepts and Techniques

Tuesday, 28 October – 13:30-17:00 Afternoon

Markus Völter, Independent consultant, voelter@acm.org

Program generation has been used for a long time to facilitate the development of enterprise and embedded systems. More recently, its potential for improving object-oriented software development in general has been realized through the use of program generation techniques such as generative programming, product line engineering, and model-driven architectures (MDA).

This tutorial introduces the most important kinds of code generation, such as model transformations, source code generation, source code transformation, byte code rewriting and reflection. We will introduce different code generation technologies, such as template-based generators, frame technology, aspect weaving and AST-based approaches; illustrate when to use them; discuss benefits and drawbacks of each approach; and look at representative tools that support each kind of program generation. Some of these tools will also be demonstrated.

Attendee background

Prerequisites: Attendees should be experienced OO developers or architects and must understand an OO programming language, such as Java, C++ or C#. Familiarity with UML is also required. Previous experience with code generation is not necessary.

Format

Lecture and live demonstrations

Presenter

Markus works as an independent consultant in software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular speaker at conferences, and co-author of Wiley's "Server Component Patterns." Over the last couple of years, Markus has architected and implemented several large enterprise systems in banking, diagnostics and automotive, on various scales. He has used code generation in the context of enterprise and embedded systems. Markus can be reached at voelter@acm.org or via http://www.voelter.de.

Grid-supported Communications Applications

Tuesday, 28 October – 13:30-15:00

Gerald Labedz, Motorola Labs, labedz1@motorola.com

This invited talk will describe how emerging distributed computing systems could mutate into the communications systems of the future. Armed with high speed interconnect, and software elements that assign, track and charge for geographically distributed computing resources, these systems could just as easily compute and deliver an image to a remote location (for human communications) as perform an internal streaming file transfer. With this kind of capability not tied to the user's premises, customer equipment could be very asset light and still deliver very high end services like realtime processed video. Using as an example MIRAGE II, a data mining system with a geographically distributed, remotely computed Augmented Reality interface, a prototype built by Motorola in association with NCSA, Labedz will discuss the main hurdles along the way to communications systems dependent on real-time remote computing and high speed networks.

Speaker

Gerry Labedz has worked at Motorola for 28 years in the areas of mobile and cellular radio hardware and software. He worked on the first microprocessor controlled radio in the '70s, the first digital cellular system in the '80s, and the world's most accurate parallel-computed cellular system simulation tool in the '90s. He holds 23 patents in the areas of radio signaling, system design and visualization, and large-scale real-time simulation for cellular system control. During the 1990s, he and his group were the largest industrial users of the supercomputer facilities at the National Center for Supercomputing Applications (NCSA). He holds the title of Dan Noble Fellow, Motorola's highest technical honor. Most recently he has led a project centering on Hyperfast Computational Communications, or HyperComputiCations

5 JPie: An Environment for Live Software Construction in Java

Tuesday, 28 October – 15:00-15:45

Wednesday, 29 October – 15:00-15:45

Kenneth Goldman, Washington University in St. Louis, kjg@cse.wustl.edu

JPie is a tightly integrated development environment supporting live object-oriented software construction in Java. JPie embodies the notion of a dynamic class whose signature and implementation can be modified at run time, with changes taking effect immediately upon existing instances of the class. The result is complete elimination of the edit-compile-test cycle. Dynamic classes are precompiled and then execute in a semi-interpreted manner using an internal representation of the dynamic portions of the class definition. Dynamic classes fully interoperate with compiled classes. Consequently, JPie users have access to the entire Java API, may create dynamic classes that extend compiled classes, and can override their methods on the fly. Instances of compiled classes may hold type-safe references to instances of dynamic classes, and may call methods on them polymorphically. All of these capabilities are achieved without modification of the language or virtual machine. JPie users create and modify class definitions through direct manipulation of visual representations of program abstractions. The visual representations expose the Java execution model, while removing the possibility of syntax errors and enabling immediate type-checking feedback. In this demonstration, we will illustrate the central features of JPie in the course of constructing an example application. These will include dynamic declaration of instance variables and methods, dynamic modification of method bodies and threads, dynamic user interface construction and event handling, and on-the-fly exception handling in JPie's integrated thread-oriented debugger.

11 ATCT: a Java Framework that Offers New Approach to Developing Asynchronous Processes

Tuesday, 28 October – 15:00-15:45

Thursday, 30 October – 11:00-11:45

Serguei Mourachov, Velare Technologies Inc., smourachov@velare.com
John van Rij, Velare Technologies Inc., jvanrij@velare.com

Velare Technologies, Inc. will demonstrate ATCT (Asynchronous Transfer of Control Threading) – a Java framework for asynchronous method invocation. ATCT facilitates development of asynchronous long-running processes in Java, using well-known OOP techniques and design patterns. Traditionally when an application interacts asynchronously with an external environment, event-driven programming is used. However, this approach makes it difficult to develop processes with complex flow logic. Moreover, programming of sophisticated workflow patterns becomes almost impossible. ATCT allows transforming the event-driven programming style into a well-known sequential programming style, enabling the use of OOP for asynchronous process development. In addition, it is possible to develop a variety of new types of applications that require manipulation of execution context. ATCT introduces a new approach for execution context reification in Virtual Machine based runtime environments. ATCT uses a secondary bytecode interpreter to execute specially marked methods in a special mode, which allows to access execution context as first class object. The secondary interpreter is written in the Java programming language allowing use of ATCT on any JVM. ATCT’s functionality and capabilities will be presented by using slides and code samples. After introducing the concept using simple examples, we will show the possibilities for complex distributed architectures by showing prototypes of frameworks for messaging and web applications. Our demonstration is targeted to people who are interested in the use of VM-oriented mainstream OO languages such as Java or C#, for new types of applications. The demonstration should also be interesting for designers of Virtual Machines and new languages.

12 Generative Model Transformer

Tuesday, 28 October – 15:00-15:45

Thursday, 30 October – 12:00-12:45

Ghica van Emde Boas, bronstee.com, emdeboas@bronstee.com
Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com

The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecture™ tool that allows fully customisable Platform Independent Models, Platform Description Models, Mappings, and Refinement Transformations. The project should result in:

  • a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development,
  • a tool for industrial use,
  • MDA related research - which is encouraged and needed.

GMT resides as a technology project on Eclipse.org.

The demo intends to show the state of the tool at the time of OOPSLA.

The software is designed using UML modeling and implemented using generative techniques. It will be implemented mainly in Java. Links will be provided to other existing tools that can fill in some of the functionality required.

GMT will provide a related set of components that can be used by other MDA tool components, and will consist of four main components:

  • A mapping component that can combine two XMI-encoded models into one new XMI-encoded model.
  • A model transformation component using XMI as input and output.
  • A text generation component, using XMI as input and text (code) as output.
  • A workflow component that provides the required glue between the three functional components above, any additional user-developed MDA tool components, and popular IDEs/tool platforms such as Eclipse.

13 Semantic Software Engineering Tools

Tuesday, 28 October – 15:00-15:45

Alexander Paar, Universität Karlsruhe, alexpaar@ieee.org

During the nineties, object orientation of software source code made possible component orientation of applications. Recently, novel component oriented runtime environments have paved the way for service oriented infrastructures. Since there may be a considerable number of service providers, which offer very similar functionality, it tends to be difficult to choose the most appropriate service and to guess the appropriate operations by interpreting syntactic operation names as provided by state of the art Web service interface descriptions. We used semantic Web technologies like DAML and OWL for constructing ontologies, which present the meaning of processed data and provided functionality. These ontologies were used to annotate both syntactic Web service descriptions as well as object oriented C# source code. This demonstration introduces the set of tools that was developed in order to implement the idea of semantic software engineering. Web Services Description Language documents are annotated with semantic information using a WSDL Annotator. A Microsoft Visual Studio add-in was developed in order to annotate C# source code and to facilitate declarative service requests that may be embedded with common C# source code. A programmer may even dictate such requests using natural language input. The Microsoft SOAP toolkit was extended to preserve semantic annotations when C# proxy classes are automatically generated from WSDL files as well as when annotated Web service descriptions are automatically generated from annotated C# source code. Our set of integrated tools increases efficiency and productivity when developing and incorporating Web services using any object oriented programming language.

Xtreme Programming and Agile Coaching

Tuesday, 28 October – 15:30-17:00

Steven Fraser (Impresario), Independent Consultant, sdfraser@acm.org
Rachel Reinitz (Chair), IBM, rreinitz@us.ibm.com
Jutta Eckstein, Independent Consultant, jutta@jeckstein.com
Joshua Kerievsky, Industrial Logic, joshua@industriallogic.com
Rob Mee, Pivotal Computer Systems, robmee@ieee.org
Mary Poppendieck, Agile Alliance, mary@poppendieck.com

This panel brings together coaches to discuss all aspects of the practice: how to become a coach, choosing a coach, and describing what is to be an (in) effective coach. A coach watches, provides feedback, and suggests subtle direction. The coach may be more—for example—an architect or team lead—but that is a matter for debate. This session will be run as a panel with two open "fish bowl" seats, only one of which may be occupied by audience members at any one time. The panelists will defend their positions and offer feedback. Panelists were asked to offer their observations on three questions: How did YOU become a coach? What's the toughest thing you've had to do as a coach? What's your advice for teams looking for a coach?

Tools

Tuesday, 28 October – 15:30-17:00

15:30 - 16:00
Experience in Developing the UrbanSim System: Tools for Developing Research Software for a Politically Charged Domain

Bjorn Freeman-Benson, Center for Urban Simulation and Policy Analysis, University of Washington, bnfb@cs.washington.edu
Alan Borning, Department of Computer Science and Engineering, University of Washington, borning@cs.washington.edu

UrbanSim is a sophisticated simulation system for modeling urban land use, transportation, and environmental impacts, over a period of 20 or more years, under alternate possible scenarios. Our purpose is to support democratic decision-making on such issues as building new transit systems or freeways, or changing zoning or economic incentives, as well as on broader issues such as sustainable, livable cities, economic vitality, social equity, and environmental preservation. The domain is politically charged, with different stakeholders bringing strongly held values to the table. Our goal is not to favor any particular stakeholder values, but rather to let the stakeholders evaluate the results themselves. This need for neutrality has several implications for the development process, among other things resulting in our choice of an open source/open process model. UrbanSim is also an NSF-funded infrastructure project with a mix of research and development goals. Unlike most academic projects, this one has real customers (municipal planning organizations) with real needs.

Thus the UrbanSim project has a number of simultaneous goals, which are in some tension: producing credible, reliable code; utilizing a flexible process that adapts to new research discoveries; maintaining coherent architecture and continuous development progress; and using part-time and inexperienced student staff in addition to experienced full-time staff. (This is in contrast to the usual model in XP and other agile development processes, in which all developers are considered equally experienced and skilled.)

In this report, we discuss the tools we have chosen, modified, or developed in-house; and the reasons why these tools are good choices for this mixed research/product development environment. Our tools include: Eclipse, MySQL, CVS, Ant, Fireman (a Tinderbox-like automatic build and test system), JUnit, FIT, Wiki, Bugzilla, a physical traffic light, and a daily project dashboard. The tools are tightly integrated and collectively support our agile process.

16:00 - 16:30
Experiences using an ODBMS for a high-volume internet banking system

Vincent Coetzee, eBucks.com, vincent.coetzee@ebucks.com
Robert Walker, GemStone Systems, bob.walker@gemstone.com

Few large corporate organizations make the decision to use an Object Database Management System (ODBMS) when developing high volume transactional eCommerce web sites. This report examines the architecture used to power a website that encompasses banking, online shopping, and the management of a Customer Loyalty Currency called eBucks. This system proves that an ODBMS can be used in a high volume transactional system with great success. While the choice of this technology has many merits, there are drawbacks. These drawbacks are examined along with the solutions that have been used at eBucks to either solve or ameliorate them.

Smalltalkiana

Tuesday, 28 October – 15:30-16:30

15:30 - 16:00
Applying Traits to the Smalltalk Collection Classes

Andrew P. Black, OGI School of Science & Engineering, Oregon Health & Science University, black@cse.ogi.edu
Nathanael Schärli, University of Bern, schaerli@iam.unibe.ch
Stéphane Ducasse, University of Bern, ducasse@iam.unibe.ch

Traits are a programming language technology modeled after mixins but avoiding their problems. This paper reports on a refactoring of the Smalltalk collections classes using traits. We observed that the original collection classes contained much duplication of code; traits let us remove all of it. We also found places where the protocols of the collections lacked uniformity; traits allow us to correct these non-uniformities without code duplication. In addition, traits make possible more general reuse of collection code outside of the existing hierarchy; for example, they make it easy to convert other collection-like things into true collections. Our refactoring reduced the number of methods in the collection classes by approximately 10 per cent. More importantly, understandability and reusability of the code was significantly improved.

16:00 - 16:30
OOPAL: Integrating Array Programming in Object-Oriented Programming

Philippe Mougin, pmougin@acm.org
Stéphane Ducasse, University Of Bern, ducasse@iam.unibe.ch

Array programming shines in its ability to express computations at a high-level of abstraction, allowing one to manipulate and query whole sets of data at once. This paper presents the OOPAL model that enhances object-oriented programming with array programming features. The goal of OOPAL is to determine a minimum set of modifications that must be made to the traditional object model in order to take advantage of the possibilities of array programming. It is based on a minimal extension of method invocation and the definition of a kernel of methods implementing the fundamental array programming operations. The model is validated in F-Script, a new scripting language.

14 MetaEdit+: Defining and using domain-specific modeling languages and code generators

Tuesday, 28 October – 16:00-16:45

Thursday, 30 October – 11:00-11:45

Juha-Pekka Tolvanen, MetaCase, jpt@metacase.com
Matti Rossi, Helsinki Business School, mrossi@hkkk.fi

MetaEdit+ is an environment that allows building modeling tools and generators fitting to application domains, without having to write a single line of code. The capability to define modeling tools and generators is relevant as it provides the ability to raise the abstraction of design work from code to domain concepts, and a raise in abstraction leads to an imminent raise in productivity, as illustrated by the past years' experiences.

In domain-specific modeling and MetaEdit+, one expert defines a domain-specific language as a metamodel containing the domain concepts and rules, and specifies the mapping from that to code in a domain-specific code generator. For the method implementation, MetaEdit+ provides a metamodeling language and tool suite for defining the method concepts, their properties, associated rules, symbols, checking reports, and generators.

Once the expert defines a modeling method, or even a partial prototype, the rest of the team can start to use it in MetaEdit+ to make models with the modeling language and the required code is automatically generated from those models. Based on the metamodel, MetaEdit+ automatically provides CASE tool functionality: diagramming editors, browsers, generators, multi-user/project/platform support, etc. MetaEdit+ is implemented in Smalltalk.

The MetaEdit+ demo will focus on showing how the domain-specific languages and generators are made; complete with several examples of domain-specific methods and related code generators.

Keywords: metamodel; domain-specific modeling languages; code generators

15 A Policy Based System to Incorporate Self-Managing Behaviors in Applications

Tuesday, 28 October – 16:00-16:45

Thursday, 30 October – 11:00-11:45

Hoi Chan, IBM T.J Watson Research Center, hychan@us.ibm.com

With the rapid increase in complexity of software systems and applications, it becomes necessary to develop tools to simplify the incorporation of self-managing features into applications. The use of object and component technologies, together with a policy system which externalizes business logic from an application, plays an important role in enabling systems with greater manageability and variability.

Current policy systems are mainly domain specific, and there is a need for an execution system which is flexible and usable across a variety of domains. Our policy execution system provides a framework which utilizes object and component technologies to separate the process of executing a policy into various components and processes. Each component and sub-process can be developed independently, configured and reused.

In our programming system, an episode of policy execution can be viewed as a composition of the following components: high level policy language definition and authoring, translation to executable code for the choice of execution mechanism, input and output, mappings of application objects and the underlying execution mechanism (rule engines, execution algorithms or strategies). Furthermore, we separate a high level policy into its various logic components: operation logic, priority logic, conflict resolution logic and each of these components can be developed and reused independently.

Our policy framework completely hides the programming details and exposes the interfaces only. In the demo, we will show how to build an application using the policy framework in various contexts with a single policy and modify the policy subsequently to illustrate the various operation of each of the components and features, and how an application uses the policy system to enhance its self-managing features. (The prototype of this system will be available for free download in 3Q of 2003.)

16 Using Events to Debug Java Programs Backwards in Time

Tuesday, 28 October – 16:00-16:45

Thursday, 30 October – 11:00-11:45

Bil Lewis, Lambda Computer Science, Bil.Lewis@LambdaCS.com
Mireille Ducassé, IRISA, ducasse@irisa.fr

An "Omniscient Debugger" works by recording all state changes in the run of a program, and then allowing the programmer to explore the history of that program— effectively going "backwards in time." Event analysis debuggers work by observing events as they occur, and allowing the programmer to write queries which will pause the program when matched.

Recently we have integrated the two techniques to produce an omniscient debugger which can use event queries to search the history of a program interactively. The query mechanism is designed along the lines of an EMACS incremental search.

The implementation of the system is in Java and records two types of events: method calls (and returns) and assignments. To our best knowledge, this is the first event model for Java.

A typical scenario is a quick sort program which neglects to sort one entry. An event search for the method call which should have sorted the entry ("Find a call to sort() whose start is less than the entry and whose end is greater") allows the programmer to get close to the bug, and the normal mechanisms of the omniscient debugger ("step forwards", "step backwards", etc.) allow the programmer to verify the exact cause of the bug.

In addition to the above (which the Prolog-based Coca system of Ducasse is capable of), it is possible to include both objects and the instance variables of those objects in the query (e.g., "Find a call to OBJ.sort() where OBJ.type is 'Integer'").

26 Time Conscious Objects

Tuesday, 28 October – 16:00-16:45

Thursday, 30 October – 13:00-13:45

Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com
Jeff Hoare, SoftMetaWare, jeff.hoare@softmetaware.com

In most business software systems the time dimension of business objects plays a significant role. Time is a crosscutting concern that is hard to separate from other business logic. We have developed a toolkit that allows existing business application systems to be extended with "time-conscious" behavior in a non-intrusive way by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base. The Time Conscious Objects™ (TCO) toolkit is currently implemented in Java™, but through the use of generation technology the toolkit can easily be made available in any language that supports polymorphism.

The TCO toolkit has been explicitly designed to allow non-intrusive and incremental integration into existing systems. Time-conscious objects can have a major impact on the quality and maintainability of applications by eliminating the complexity of dealing with the time dimension. This is the case for example in time-based billing systems, in the insurance industry, and in the modeling of "parts" in ERP and manufacturing systems.

The demonstration provides an overview of the architecture and the APIs that TCO uses to integrate with existing application system environments. Beyond that, the demonstration shows on the basis of one or more small example applications, how TCO can be used to raise the level of abstraction in platform independent models and in business application code.

TCO product development is work-in-progress and the demonstration is intended to be highly interactive, giving the audience opportunity to raise and discuss their specific time-dimension-related requirements.

Java Community Process reception, hosted by Sun Microsystems

Tuesday, 28 October – 17:30-19:30

The Java Community Process℠ (JCP℠) program is where the future of Java™ technology is defined. It is an open organization of Java developers who collaborate to develop Java technology. The best minds in the industry and academic worlds come together to ensure compatibility and interoperability of Java technology.

Come to the JCP meeting on Tuesday evening to find out about proposed Java specifications and language changes being developed now through the JCP, including generics, concurrency utilities, autoboxing, metadata, new I/O APIs, management extensions and more. This will be an opportunity to meet with and hear first hand from the JCP spec leads and experts involved with these specification proposals. Food and drink will be provided.

eclipse Plug-in Reception, hosted by eclipse

Tuesday, 28 October – 19:30-22:00

The eclipse community invites you to a special plug-in and coding reception on Tuesday October 28th.

We'd like to especially invite members of the contributing eclipse community - that is, plug-in writers and eclipse users who have contributed to the eclipse project's success! We'd like you to meet each other and some members of the eclipse development team, to interact and share ideas about your project and the exciting things in store for eclipse!

We'll give a brief overview of what's new in the eclipse project and then open the evening for an informal get-together. Bring your laptop and get plugged-in! In cooperation with the IBM Eclipse Technology Network, we'll have a space set aside where you can check out Code Rally - a programming road race - so bring your network adaptor too!