Wednesday, 29 October

8:30-10:00	Keynotes & Invited Speakers: Seven Paradoxes of Object-Oriented Programming Languages
10:00-17:00	Poster: Posters on display
10:30-12:00	Technical Paper Technical Papers and Onward!: Error Repair Technical Paper: Generics Panel: Discipline and Practices of TDD (Test Driven Development) Onward!: Acceptability-Oriented Computing Domain-Driven Development: Vision
11:00-11:45	Demonstration 17: Redeveloping a High-Performance Computing FrameWork Demonstration 18: Do You Still Use a Database? Demonstration 20 Jazz: A Collaborative Application Development Environment Demonstration 22 T++ : A Tool for Web Application Development with C++
12:00-12:45	Demonstration 2: Smart Play-Out Demonstration 23: AspectJ Development Tools Demonstration 24 Variant Management for Embedded Software Product Lines with Pure::Consul and AspectC++ Demonstration 27 Visual SDLC: Improving Requirements Engineering for Object-Oriented Systems
13:30-17:00 Afternoon	Tutorial 44: Notes on the Forgotten Art of Software Architecture Tutorial 45: Test-Driven Development with "fit", the Framework for Integrated Test Tutorial 46 Object-Oriented Reengineering: Patterns & Techniques Tutorial 47: Enterprise Application Integration with J2EE and .NET Tutorial 48: Guided Inspection of UML Models Tutorial 49: Extending Enterprise Systems with Mobile/Wireless Applications Tutorial 50: Understanding Circa-2003 XML Technologies Tutorial 51: Designing Reliable Collaborations Tutorial 52 Agile Database Techniques: Data Doesn't Have To Be A Four Letter Word Anymore
13:30-15:00	Technical Paper: Java Performance Panel: Innovate! Practitioners Report: Old Code Domain-Driven Development: Technology
15:00-15:45	Demonstration 3: Visualizing and AspectJ-enabling Eclipse Plugins using Bytecode Instrumentation Demonstration 4: Automated Impact Analysis of Objected Oriented Software Demonstration 5 JPie: An Environment for Live Software Construction in Java Demonstration 21: Requirements Use case Tool (RUT)
15:30-17:00	Technical Paper: Language Design Panel Model Driven Architecture: How far have we come, how far can we go? Practitioners Report: Real-World Objects Onward!: The Biology of Information
16:00-16:45	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 Demonstration 25: Building Compilers For Micro-programmable Graphics Processors
19:00-23:00	Special Event: The Big Event

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.

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.

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.

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.

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.

Seven Paradoxes of Object-Oriented Programming Languages

Wednesday, 29 October – 8:30-10:00

David Ungar, Sun Microsystems

Although many of us have worked to create good object-oriented programming languages, it would be hard to say (with a straight face) that any of our creations have totally succeeded. Why not? I believe that this endeavor is essentially paradoxical. Thus, whenever a language designer pursues a particular goal and loses sight of the lurking paradox, the outcome is an all too often fatally flawed result. One way to think about this is to explore the following seven paradoxes:

Because programming languages, development environments, and execution engines are intended for both people and computers, they must both humanize and dehumanize us.
Adding a richer set of concepts to a programming language impoverishes its universe of discourse.
Putting a language's cognitive center in a more dynamic place reduces the verbiage needed to accomplish a task, even though less information can be mechanically deduced about the program.
The most concrete notions are the most abstract, and pursuing comfort or correctness with precision leads to fuzziness.
Although a language, environment, and execution engine are designed for the users' minds, the experience of use will alter the users' minds.
Object-oriented programming has its roots in modeling and reuse, yet these notions do not coincide and even conflict with each other.
A language designed to give programmers what they want may initially succeed but create pernicious problems as it catches on. However, a language designed to give programmers what they really need may never catch fire at all.

Many of these assertions seem nonsensical, misguided, or just plain wrong. Yet, a deeper understanding of these paradoxes can point the way to better designs for object-oriented programming languages.

Technical Papers and Onward!: Error Repair

Wednesday, 29 October – 10:30-12:00

11:30 - 12:00

Automatic Detection and Repair of Errors in Data Structures

Brian Demsky, MIT Laboratory for Computer Science, bdemsky@mit.edu
Martin Rinard, MIT Laboratory for Computer Science, rinard@lcs.mit.edu

We present a system that accepts a specification of key data structure constraints, then dynamically detects and repairs violations of these constraints, enabling the program to continue to execute productively even in the face of otherwise crippling errors. Our experience using our system indicates that the specifications are relatively easy to develop once one understands the data structures. Furthermore, for our set of benchmark applications, our system can effectively repair errors to deliver consistent data structures that allow the program to continue to operate successfully within its designed operating envelope.

Generics

Wednesday, 29 October – 10:30-12:00

10:30 - 11:00

A First-Class Approach to Genericity

Eric Allen, Rice University, eallen@cs.rice.edu
Jonathan Bannet, Rice University, jbannet@rice.edu
Robert Cartwright, Rice University, cork@cs.rice.edu

This paper describes how to add first class generic types—including mixins—to strongly-typed, object-oriented languages with nominal (name-based) subtyping such as Java and C#. A generic type system is "first-class" if generic types can appear in any context where conventional types can appear. In this context, a mixin is simply a generic class that extends one its type parameters, e.g., a class C<T> that extends T. Although mixins of this form are widely used in C++ (via templates), they are clumsy and error-prone because C++ treats mixins as macros, forcing each mixin instantiation to be separately compiled and type-checked. The abstraction embodied in a mixin is never separately analyzed.

Our formulation of mixins using first class genericity accommodates sound local (class-by-class) type checking, in the same sense that Java supports local (class-by-class) compilation. A mixin can be fully type-checked given symbol tables for each of the classes that it directly references—the same context in which Java performs incremental class compilation. To our knowledge no previous formal analysis of first-class genericity in languages with nominal type systems has been conducted, which is surprising because nominal type systems have become predominant in mainstream object-oriented programming languages.

What makes our treatment of first class genericity particularly interesting and important is the fact that it can be added to the existing Java language without any change to the underlying Java Virtual Machine. Moreover, the extension is backward compatible with legacy Java source and class files. Although our discussion of a practical implementation strategy focuses on Java, the same scheme could be applied to other object-oriented languages such as C# or Eiffel that support incremental compilation, dynamic class loading, and a static type system with nominal subtyping.

11:00 - 11:30

A Comparative Study of Language Support for Generic Programming

Ronald Garcia, Indiana University, garcia@osl.iu.edu
Jaakko Jarvi, Indiana University, jajarvi@osl.iu.edu
Andrew Lumsdaine, Indiana University, lums@osl.iu.edu
Jeremy Siek, Indiana University, jsiek@osl.iu.edu
Jeremiah Willcock, Indiana University, jewillco@osl.iu.edu

Many modern programming languages support basic generic programming, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support to a broader, more powerful interpretation of generic programming, and their extensions have proven valuable in practice. This paper reports on a comprehensive comparison of generics in six programming languages: C++, Standard ML, Haskell, Eiffel, Java (with its proposed generics extension), and Generic C#. By implementing a substantial example in each of these languages, we identify eight language features that support this broader view of generic programming. We find these features are necessary to avoid awkward designs, poor maintainability, unnecessary run-time checks, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to provide powerful generics and that their absence causes serious difficulties for programmers.

11:30 - 12:00

Lightweight Confinement for Featherweight Java

Tian Zhao, University of Wisconsin, Milwaukee, tzhao@cs.uwm.edu
Jens Palsberg, Purdue University, palsberg@cs.purdue.edu
Jan Vitek, Purdue University, jv@cs.purdue.edu

Confinement properties impose a structure on object graphs which can be used to enforce encapsulation— which is essential to certain program optimizations, to modular reasoning, and in many cases to software assurance. This paper formalizes the notion of confined type in the context of Featherweight Java. A static type system that mirrors the informal rules of Vitek and Bokopwski is proposed and proven sound. The definition of confined types is extended to confined instantiation of generic classes. Thus allowing for confined collection types in Java and for classes that can be confined post hoc. Confinement types rules are given for Generic Featherweight Java, and proven sound.

Discipline and Practices of TDD (Test Driven Development)

Wednesday, 29 October – 10:30-12:00

Steven Fraser (Chair), Independent Consultant, sdfraser@acm.org
Dave Astels, Adaption Software, dave@adaptionsoft.com
Kent Beck, Three Rivers Institute, kent@threeriversinstitute.org
Barry Boehm, USC, boehm@cse.usc.edu
John McGregor, Clemson University, johnmc@cs.clemson.edu
James Newkirk, Microsoft, jamesnew@microsoft.com
Charlie Poole, Poole Consulting, poole@pooleconsulting.com

This panel brings together practitioners with experience in Agile and XP methodologies to discuss the approaches and benefits of applying Test Driven Development (TDD). The goal of TDD is clean code that works. The mantra of TDD is: write a test; make it run; and make it right. Open questions to be addressed by the panel include:

How are TDD approaches to be applied to databases, GUIs, and distributed systems?
What are the quantitative benchmarks that can demonstrate the value of TDD, and
What are the best approaches to solve the ubiquitous issue of scalability?

Acceptability-Oriented Computing

Wednesday, 29 October – 10:30-12:00

These papers talk about a new approach to constructing software systems in which the designer identifies key properties that the execution must satisfy to be acceptable to its users. The resulting system consists of layers of components enforcing the acceptability properties.

Acceptability-Oriented Computing

Martin Rinard, MIT, rinard@lcs.mit.edu

We propose a new approach to the construction of software systems. Instead of attempting to build a system that is as free of errors as possible, we instead propose that the designer identify key properties that the execution must satisfy to be acceptable to its users. The developer then augments the system with a layered set of components, each of which enforces one of the acceptability properties. The potential advantages of this approach include more flexible, resilient systems that recover from errors and behave acceptably across a wide range of operating environments, an appropriately prioritized investment of engineering resources, and reduced development costs because of the ability to productively incorporate unreliable components into the final software system and to use less skilled implementors in the development process.

Automatic Detection and Repair of Errors in Data Structures

Brian Demsky, MIT, demsky@lcs.mit.edu
Martin Rinard, MIT, rinard@lcs.mit.edu

Vision

Wednesday, 29 October – 10:30-12:00

Chair: Krzysztof Czarnecki, University of Waterloo, ddd@oopsla.acm.org

10:30 - 11:00

Model Driven Development - The Case for Domain Oriented Programming

Dave Thomas, Bedarra Research Labs, dave@bedarra.com
Brian Barry, Bedarra Research Labs, brian@bedarra.com

In this paper, we offer an alternative vision for domain driven development (3D). Our approach is model driven and emphasizes the use of generic and specific domain oriented programming (DOP) languages. DOP uses strong specific languages, which directly incorporate domain abstractions, to allow knowledgeable end users to succinctly express their needs in the form of an application computation. Most domain driven development (3D) approaches and techniques are targeted at professional software engineers and computer scientists. We argue that DOP offers a promising alternative. Specifically we are focused on empowering application developers who have extensive domain knowledge as well as sound foundations in their professions, but may not be formally trained in computer science. We provide a brief survey of DOP experiences, which show that many of the best practices such as patterns, refactoring, and pair programming are naturally and ideally practiced in a MDD setting. We compare and contrast DOP with other popular approaches, most of which are deeply rooted in the OO community. Finally we highlight challenges and opportunities in the design and implementation of such languages.

11:00 - 11:30

An End to End Domain Driven Developement Framework

Aditya Agrawal, ISIS, Vanderbilt University, aditya.agrawal@vanderbilt.edu
Gabor Karsai, ISIS, Vanderbilt University, gabor@vuse.vanderbilt.edu
Akos Ledeczi, ISIS, Vanderbilt University, akos@isis.vanderbilt.edu

This paper presents a comprehensive, domain-driven framework for development. It consists of a meta-programmable domain-specific modeling environment, and a model transformation and generation toolset based on graph transformations. The framework allows the creation of custom, domain-oriented programming environments that support end-user programmability. In addition, the framework could be considered an early, end-to-end implementation of the concepts advocated by the Model-Driven Architecture of OMG.

11:30 - 12:00

Software Factories: Assembling Applications With Patterns, Models, Frameworks and Tools

Jack J. Greenfield, Microsoft, Visual Studio, Enterprise Frameworks And Tools, jackgr@microsoft.com
Keith W. Short, Microsoft, Visual Studio, Enterprise Frameworks And Tools, keithsh@microsoft.com

The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greater gains in productivity and predictability than those produced by the incremental advances of recent memory, which have not kept pace with rapid innovation in platform technology. Focusing on development by assembly using domain specific languages, patterns, models, frameworks and tools, software factories make systematic reuse cost effective for many applications, enabling the formation of supply chains and opening the door to mass customization.

17 Redeveloping a High-Performance Computing FrameWork

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

Scott Spetka, ITT Industries and SUNY Institute of Technology, scott@cs.sunyit.edu
George Ramseyer, Air Force Research Laboratory, George.Ramseyer@rl.af.mil
Richard Linderman, Air Force Research Laboratory, Richard.Linderman@rl.af.mil

The High-Performance Computing (HPC) FrameWork is an object-oriented system that is designed to allow users to develop and execute HPC codes on geographically distributed high-performance computer (HPC) systems. The architecture was developed to support a set of image processing applications but can adapt to additional HPC application domains. Over the last year, an initial implementation of the system has been redeveloped using emerging object-oriented technologies.

The FrameWork's Kerberos-based client authentication services, initially implemented in C++, were replaced by a Java Server Pages (JSP) approach, based on the Globus Toolkit. Using the Gateway Portal project software enables future development of Grid capabilities for the FrameWork and establishes it as a Grid portal for HPC applications. Most client functionality is C++ code invoked by JSP Java Beans.

An HPC code adaptor object has been significantly refactored following successful alpha testing of the FrameWork. Initially, we only supported simple parameters for each of the HPC codes and ignored diverse sets of outputs for each of the codes. Redeveloping objects for two of the HPC codes to address these issues required a lot of expertise and understanding of the code which proved expensive. The refactored code adaptor object allows developers to focus on their input and output requirements. Using an XML description of input parameters and HPC code outputs further reduces the programming effort required.

This demonstration will follow a processing request through the system and then discuss C++/JSP/Grid portal client implementation issues and illustrate our approach to developing the HPC code adaptor object.

Keywords: Globus Toolkit, Grid, Gateway Portal, Refactoring, CGI, JSP, XML, HPC, Kerberos, Java Beans

18 Do You Still Use a Database?

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

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

Klaus Wuestefeld, Objective Solutions, klaus@objective.com.br

This is the demo of Prevayler, the original free-software Prevalence layer for Java.

System Prevalence is transparent persistence and transparent replication of native business objects. Prevayler makes any old Java VM logically invulnerable for business objects without the need for pre or post-processing.

Queries run 3 to 4 orders of magnitude faster than using a database through JDBC even with the whole database cached locally in RAM.

DBMSs are the single most hampering force acting on the OO community. While they provide us with vital services, such as the babies born inside the Matrix, we are also pitifully atrophied by the restrictions they impose.

Instead of maiming our object design, Prevalence frees us to use the observer pattern among thousands of business objects or to run polymorphic queries on millions of them - some basic examples that would be way too slow, even on OO databases.

We are no longer restricted to the query language, algorithms and data-structures provided with our database.

Prevayler has been ported to several languages including Python, Perl, C#, Objective C, Ruby and a Smalltalk port by Kent Beck and friends.

Witness the transparent persistence and replication of an application running on Prevayler and discuss:

The simple concepts that make it possible;
The 350 lines of insanely refactored Prevayler source-code;
The shortcomings of the technology;
The adoption by the community.

Above all, you'll be able to shutdown your database and start using the full potential of OO.

Keywords: Prevalence, Persistence, Transparent.

20 Jazz: A Collaborative Application Development Environment

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

Li-Te Cheng, Collaborative User Experience Group, IBM Research, li-te_cheng@us.ibm.com
Susanne Hupfer, Collaborative User Experience Group, IBM Research, shupfer@us.ibm.com
Steven Ross, Collaborative User Experience Group, IBM Research, steven_ross@us.ibm.com
John Patterson, Collaborative User Experience Group, IBM Research, john_patterson@us.ibm.com
Bryan Clark, Clarkson University, clarkbw@clarkson.edu
Cleidson de Souza, University of California, Irvine, cdesouza@ics.uci.edu

Collaboration is vital in any team-based software development effort, and traditionally occurs in the source control repository or in applications outside the IDE (e.g. email, instant messaging). The Jazz project extends the IDE with collaborative capabilities, focusing on adding awareness, coordination, and communication among a small team of developers. Our goal is to provide easy, in-context, yet unobtrusive access to as much team information as possible. We demonstrate this in our prototype by contributing a number of collaborative plug-ins to the Eclipse Java development environment.

Teams and their members are shown with their online status and information on the activities they are engaged in. Each team has an associated group discussion board, one-to-one chats to discuss source code, and screen sharing facilities for joint debugging and code walkthroughs. Team members can define, assign, and relate activities, which include tasks and source control events, and these are automatically logged in the discussion board and linked with relevant source files. In addition to people-centered awareness, the Jazz project provides resource-centered awareness. Through decorators in the package explorer, a user can tell which files have been checked out, modified, and checked in. Markers next to code are used to indicate modifications, annotations, chats about a particular region of code, and associated activities.

Keywords: Eclipse, IDE, application development, integrated development environment, collaborative computing, collaborative software engineering, collaborative development environment, CSCW, groupware, Java

22 T++ : A Tool for Web Application Development with C++

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

Antonio Terceiro, Federal University of Bahia, terceiro@im.ufba.br
Christina Chavez, Federal University of Bahia, flach@im.ufba.br

C++ is widely used in application development, and there is no consolidated engine for web application development in C++. This work demonstrates T++, a tool for using C++ in web application development.

T++ works like JSP does for JAVA, and looks like other web programming tools: special documents have markup content, like HTML, mixed with C++ source code, which is executed when an user requests that document.

The expected audience for this presentation are software developers interested in using C++ to develop web applications.

T++ itself, the internal engine, is object oriented. The programming interface is object oriented too: documents generates classes that extend a T++ standard class, and can define methods, attributes and other members.

T++ is a free software engine that brings together some different techniques to provide a highly usable, efficient and safe tool for web development. Those techniques include shared memory allocation for C++ objects and dynamic C++ class loading. Running T++ requires a GNU/Linux system, an Apache web server, and GNU Compiler Collection (gcc) with support to C++.

This demonstration will show the basics of web application development with T++, including how to set up the T++ engine, how to program with T++, and some web development techniques.

Keywords: Web application development, C++

24 Variant Management for Embedded Software Product Lines with Pure::Consul and AspectC++

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

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

Danilo Beuche, pure-systems GmbH, danilo.beuche@pure-systems.com
Olaf Spinczyk, Friedrich-Alexander-Universität Erlangen, olaf.spinczyk@informatik.uni-erlangen.de

Software for embedded systems faces some special constraints not found in other domains. One of these constraints is a hard limitation on available RAM/ROM, processing power, and other resources. To cope with these limitations without losing the reusability of the software components, product line technologies are a promising approach. However, adequate tools for variant management are still rare.

In the demonstration we will apply Pure::Consul, a tool which supports the description of problem and solution domains of product lines, software families, or other variable artifacts in a highly flexible manner, to a realistic application scenario: a weather station product line running on a small 8 bit microcontroller with only a few KBytes of memory.

Problem domain modeling with Pure::Consul is based on extended feature models. The tool allows for integration of many different variability realization techniques through its customizable transformation backend. Thus, it is able to incorporate frame processors, code generators, or arbitrary other tools.

The implementation of the presented product line is based on AspectC++, an aspect-oriented extension to C++. We will demonstrate that by applying aspect-oriented software development, the number of configuration points in the code can be reduced. Both tools together form an ideal tool chain for embedded software product line development as one reduces the configuration complexity on the source code level, while the other helps to manage the variability on the abstract feature level and provides a mapping of features to aspects, classes, or other modularization units.

27 Visual SDLC: Improving Requirements Engineering for Object-Oriented Systems

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

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

Marc Raygoza, Visual SDLC CTO, mraygoza@cmu.edu

In theory, requirements engineering solves many of software engineering's fundamental problems. The stakeholders know what the developers are building, why they are building it, when they are building it, and even to some degree, how they are building it. If requirements engineering resolves some of the basic communication issues between IT and the business, why aren't more companies actively practicing this discipline? In practice, requirements engineering is almost impractical without a commercial automation tool. The critics argue that the current automation tools do not convincingly demonstrate its value proposition, or fulfill the longstanding promises of the leading requirements engineering experts. This paper describes how the enterprise software development lifecycle management solution, Visual SDLC, addresses some of the outstanding issues of the present requirements engineering tools.

44 Notes on the Forgotten Art of Software Architecture

Wednesday, 29 October – 13:30-17:00 Afternoon

Frank Buschmann, Siemens AG, Corporate Technology, Frank.Buschmann@siemens.com

Quality software systems require quality software architectures. Otherwise it is hard, if not impossible, to meet their functional and non-functional requirements and to master their inherent complexity. For instance, software architectures for systems with end-to-end quality of service demands, systems with stringent security requirements, or systems that are supposed to be in operation for 20+ years cannot be created on the fly, using contemporary middleware and tools. Instead, these architectures must be crafted with care, following a defined specification process and making thoughtful design decisions.

This tutorial explores some of the timeless secrets of building high-quality software architectures, in terms of process, methodology, design goals, and architectural properties, to convey the foundations of building successful software.

Attendee background

Prerequisites: Participants must have experience with object-oriented software design and development.

Format

Lecture

Presenter

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects."

45 Test-Driven Development with "fit", the Framework for Integrated Test

Wednesday, 29 October – 13:30-17:00 Afternoon

Ward Cunningham, Cunningham & Cunningham, Inc., ward@c2.com

This tutorial introduces the Framework for Integrated Test (fit) and demonstrates its use in Test-Driven Development (TDD), as practiced in Extreme Programming and other agile development methods. Projects use fit-style tests both to guide programming and to test the correctness of the result. Test-driven designs are more easily "refactored," making it the only programming method that expects programs to get "cleaner" over time.

Short lectures will explain just enough of Extreme Programming to establish the context for test-driven design. These will be followed by live demonstrations and laboratory exercises. The labs will use simple Java, but the emphasis is on familiarity with the frameworks, tools and techniques, not programming. If you are unfamiliar with Java, you will learn enough just by watching to be able to complete some of the exercises and obtain all of the benefits of the tutorial.

Bring a laptop, or join someone who has one, to do hands-on exercises. Bring a wireless networking card to participate in additional "online" activities. Install Java at home to save time in class. Google "sun java download" to find a version for your computer.

Attendee background

Prerequisites: Some programming experience with an object-oriented language is required (not necessarily Java). Familiarity with downloading and installing software is also required.

Format

Lecture, demonstration, and optional exercises

Presenter

Ward Cunningham is a founder of Cunningham & Cunningham, Inc. He has served as Director of R&D at Wyatt Software and as Principle Engineer in the Tektronix Computer Research Laboratory. Ward is well known for his contributions to the developing practice of object-oriented programming, the variation called Extreme Programming, and the communities hosted by his WikiWikiWeb.

46 Object-Oriented Reengineering: Patterns & Techniques

Wednesday, 29 October – 13:30-17:00 Afternoon

Serge Demeyer, University of Antwerp (Belgium), serge.demeyer@ua.ac.be
Stéphane Ducasse, University of Berne (Switzerland), ducasse@iam.unibe.ch
Oscar Nierstrasz, University of Berne (Switzerland), oscar@iam.unibe.ch

Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Software engineers are now confronted with millions of lines of code, developed using object-oriented design methods and languages of the