8:30-10:00

10:00-17:00

10:30-17:00

10:30-12:00

11:00-11:45

12:00-13:30

12:00-12:45

13:30-17:00 Afternoon

13:30-15:00

15:00-15:45

15:30-17:00

15:30-16:30

16:00-16:45

17:30-19:30

19:30-22:00

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

Refactoring and Reflection

Tuesday, 28 October – 10:30-12: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.

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).

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

Naturalistic Programming and Run-Time Code Generation

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

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

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

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

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

Philippe Mougin, -, pmougin@acm.org

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

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

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

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

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

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

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

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

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

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

41 C++ Threading: A Generic-Programming Approach

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

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

43 Program Generation: Concepts and Techniques

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

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

Grid-supported Communications Applications

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

Gerald Labedz, Motorola Labs, labedz1@motorola.com

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

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