Monday, 27 October

8:30-17:30 Full day

Doctoral Symposium:
Educators' Symposium: Educators' Symposium

8:30-17:00 Full day

Tutorial 34: Developing Java Applications for Small Devices Using Eclipse
Tutorial 35: Essential Object-Oriented Analysis and Design
Tutorial 36 Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects
Workshop 1: Reuse in Constrained Environments
Workshop 3: Generative techniques in the context of MDA
Workshop 4: Agile Contracts
Workshop 5: The Twelfth OOPSLA Workshop on Behavioral Semantics— Striving for Simplicity
Workshop 8: Multiple Viewpoints for System Modeling
Workshop 10: Pervasive Computing; going beyond Internet for small screens
Workshop 13 Beyond Green-Field Software Development: Strategies for Reengineering and Evolution
Workshop 14: Semantics of Enterprise Integration III
Workshop 18 Bridging the Gap: Examining Approaches that Connect Business Requirements to Enabling Technology Solutions
Workshop 19: Eclipse Technology eXchange
Workshop 21: 2nd International Workshop on Language Agnostic Runtimes and Component Based Architectures
Workshop 22: Web Services and Service-Oriented Architecture Best Practices and Patterns

8:30-12:00 Morning

Tutorial 20: The C# Programming Language
Tutorial 22: Garbage Collection
Tutorial 23: Beyond the Gang of Four
Tutorial 24: Patterns of Enterprise Application Architecture
Tutorial 25: Agile Requirements Specification
Tutorial 26: Patterns for High Performance Systems
Tutorial 29 Foundations of Object-Oriented Languages: Types and Language Design

13:30-17:00 Afternoon

Tutorial 27: Java Reflection
Tutorial 28: Enterprise Integration Patterns
Tutorial 30 Large-Scale Software Architecture: A Practical Guide Using UML
Tutorial 31: Technical Leadership In Practice
Tutorial 32: Domain-Driven Design
Tutorial 33: From Component Reuse to Asset-Based Software Engineering
Tutorial 42: Agile Use Cases


Poster: Posters on display
The ACM SIGPLAN Student Research Competition: Student Research Poster Presentations at the Welcome Reception
Special Event: OOPSLA 2003 Welcome Reception


Special Event: Newcomers Orientation

Monday, 27 October – 8:30-17:30 Full day

Educators' Symposium

Monday, 27 October – 8:30-17:30 Full day

8:30 - 8:40
Welcome and Introduction— Educators' Symposium Chair

8:40 - 9:20
Invited Talk I: Things They Would Not Teach Me of in College: What Microsoft Developers Learn Later

Eric Brechner, Microsoft Development Training, Microsoft,

There has always been a gap between what college graduates in any field are taught and what they need to know to work in industry. However, today the gap in Computer Science has grown into a chasm. Current college hires who join Microsoft development teams only know a small fraction of their jobs and cannot be trusted to write new code until they have received months of in-depth training. The cause of this growing gap is a fundamental shift in the software industry, which now demands higher quality and greater attention to customer needs. This paper presents five new courses to add to computer science curriculums to help close this gap.

9:20 - 10:00
Invited Talk II: An Educational Perspective on Database Management Systems and Object-Oriented Methodology: A 12 Year Journey

Shahram Ghandeharizadeh, University of Southern California

This presentation is based on the speaker's experience of teaching OO methodology in the Computer Science Department of the University of Southern California. It describes OO concepts that relate to database management system. Several fundamental student misperceptions and their solutions have been addressed. A set of tools that enhance the educational activities are discussed.

10:00 - 10:30
Coffee Break

10:30 - 12:00
Paper Presentation I

10:30 - 11:00
Methodology First and Language Second-A way to Teach OO

Haibin Zhu, Nipissing University,
MengChu Zhou, New Jersey Institute of Technology,

C++ is a very successful object-oriented language. It is a required language for more and more students. It takes great effort and practice for these students to learn how to program in C++ and how to make object-oriented programs. One potential failure is that they have learned programming in C++ but do not know how to program in an object-oriented (OO) style. To avoid such failures, this paper proposes that first an object-oriented methodology is taught, and then the language itself. A six-step approach to teach the OO methodology is presented, followed by some innovative ways to teach different mechanisms in C++. In this way, students can master both object-oriented programming and C++ programming. The proposed teaching method is applicable to teaching other languages like Java and C#.

11:00 - 11:30
Rethinking Computer Science Education from a Test-First Perspective

Stephen Edwards, Virginia Tech,

Despite our best efforts and intentions as educators, student programmers continue to struggle in acquiring comprehension and analysis skills. Students believe that once a program runs on sample data, it is correct; most programming errors are reported by the compiler; when a program misbehaves, shuffling statements and tweaking expressions to see what happens is the best debugging approach. This paper presents a new vision for computer science education centered around the use of test-driven development in all programming assignments, from the beginning of CS1. A key element to the strategy is comprehensive, automated evaluation of student work, in terms of correctness, the thoroughness and validity of the student's tests, and an automatic coding style assessment performed using industrial-strength tools. By systematically applying the strategy across the curriculum as part of a student's regular programming activities, and by providing rapid, concrete, useful feedback that students find valuable, it is possible to induce a cultural shift in how students behave. (Topics: "How to teach C# in CS Curriculum," "How to become a good OO programmer," ".NET technology and CS/CIS Curriculum," "Whether and how to teach J2EE" and more.)

11:30 - 12:00
Object Oriented Principles in CS1

Carl G. Alphonce and Philip R. Ventura, University at Buffalo, SUNY,

Teaching object-oriented programming in CS1 is hard. Keeping the attention of CS1 students is perhaps even harder. In our experience the former can be done successfully with very satisfying results by focusing on the fundamental principles of object-orientation, such as inheritance, polymorphism and encapsulation. The latter can be done by having students create graphical event-driven programs. Teaching graphics can easily distract students and certainly takes time away from the fundamentals being taught. We use Java as a vehicle for OO instruction, but rather than expose CS1 students to the intricacies of Swing we employ an elegant and small graphics package called NGP. NGP, developed at Brown University by Andries van Dam, allows students to create event-driven graphical programs using only inheritance and method overriding. We describe how we use NGP to enhance rather than detract from our teaching of fundamental OO principles.

12:00 - 13:00
Educators' Symposium Lunch and Round Table Discussions

13:00 - 14:30
Paper Presentations II

13:00 - 13:30
Reality Abstraction and OO Pedagogy: Results From 5 Weeks in Virtual Reality

John Towell, Carroll College,
Elizabeth Towell, Carroll College,

A five week program which involves exposure to a complex object-oriented virtual environment was evaluated for efficacy in learning fundamental object oriented principles. Students(n=57) from two CS1 classes were asked to write essays on their knowledge of object-oriented programming concepts following their participation in the program. A systemic method for evaluating student knowledge was followed by rating the student's knowledge on a one-to-five rating scale. The results indicated that the students understood, by virtue of their ability to write intelligibly, the concepts of abstraction, inheritance and method override. Demonstrated knowledge of the concept of state was far less convincing.

13:30 - 14:00
Teaching Polymorphism with Elementary Design Patterns

Joe Bergin, Pace University,

Polymorphism is often treated as an advanced topic by educators. Many feel that if statements are in some sense more "fundamental" to computing. On the contrary, polymorphism is both fundamental to object programming and is an elementary topic that can be easily understood by students. Previous papers have shown how role play exercises can remind students that they already have a deep understanding of dynamic polymorphism. The question then becomes how do we find effective teaching techniques to present this topic when we move from the level of metaphor to that of programming. A few elementary patterns can be used to teach this topic even before the student is introduced to ad-hoc selection with if statements. Teaching these patterns early has the added benefit that they are pervasive in the Java libraries, so understanding them eases the student's later work.

14:00 - 14:30
ProfessorJ: A Gradual Intro to Java Through Language Levels

Kathryn Gray, University of Utah,
Matthew Flatt, University of Utah,

In the second-semester programming course at the University of Utah, we have observed our students suffering unnecessarily from a mismatch between the course content and the programming environment. The course is typical, in that it exposes students to Java a little at a time. The programming environments are also typical, in that they report compilation and run-time errors in the jargon of professional programmers with references to the full Java language. As a result, students rely heavily on teaching assistants to interpret errors, and valuable classroom time is wasted on diversions.

ProfessorJ is our new programming environment that remedies this problem. Like other pedagogical environments, such as BlueJ and DrJava, ProfessorJ presents the student with a simplified interface to the Java compiler and virtual machine. Unlike existing environments, ProfessorJ tailors the Java language and error messages to the students' needs. Since their needs evolve through the course, ProfessorJ offers several language levels, from Beginner Java to Full Java.

14:30 - 15:00
Doctoral Symposium and Other Conference Reports

15:00 - 16:00
Poster Session and Coffee Break

Preparing Undergraduate Students for Java Certification

Arial Ortiz, ITESM, Campus Estado de Mexico,

Java certification promises to make our students more marketable once they graduate. The truth is that certifications in general offer significant advantages, but it is important not to overestimate their benefits. In this paper, we describe our experiences on teaching a workshop aimed at preparing undergraduate students for the Sun Certified Java Programmer exam. But first, we layout the real value of IT certifications and explain the different certification options available for Java technology.

Reuse of Teaching Components, a UML-Based Approach to Delivering and Managing Academic Courses

Luis Palomino Ramirez, ITESM, Campus Guadalajara Department of Computer Science,
Juan Antonio Vega Fernandez, ITESM, Campus Guadalajara Department of Computer Science,

In this paper we present a model for the representation of academic courses based on the organization and semantic relation of reusable teaching components using the unified modeling language. We describe an application of the model to cs101, but we believed that the model can be applied to any subject content of any discipline. Results indicate that by following this model, the knowledge of more experienced teachers can be stored in its representation and the course components are easier to reuse by less experienced teachers.

A Pair-Programming Experiment in a Non-Programming Course

Edward Gehringer, North Carolina State University,

Pair programming is a concept where two programmers work side by side at the same computer, writing code jointly. One of them, called the driver, is in control of the keyboard and mouse. The other, called the navigator, observes what the driver is doing and offers advice. It is the driver's job to write the code. The navigator has a chance to observe the larger picture, evaluating the driver’s code for correctness of design and implementation. Studies have shown that pair programming is very effective. Two programmers can finish a task in little over half the elapsed time that a single programmer takes. And the quality of the code measured in terms of absence of defects is much higher.

In the past few years, pair programming has made inroads into industry and into programming courses. However, it has not typically been used in courses that teach subjects other than programming or software engineering, nor has it been used in the analysis of experimental results. This paper reports on an experiment in a combined senior/masters level computer architecture class, using Hennessy and Patterson's Computer Architecture: A Quantitative Approach as a text. Students were required to implement three projects simulating various aspects of a micro-architecture (cache, branch predictor, dynamic instruction scheduler). Then they engaged in an experimental analysis to find the best configuration in a design space. Students reported high levels of satisfaction with the experience of pair programming. Pair programmers obtained significantly higher grades on Project 1; however, differences on the other projects were not statistically significant.

A Framework for Building Language Interpreters

Alan Durham, University of São Paulo, Brazil,
Edson Sussumu, University of São Paulo, Brazil,
Arlido Flavio da Conceicao, University of São Paulo, Brazil,

This work presents an Object-Oriented framework for language interpreters development. We use this framework to implement different programming language paradigms, including interpreters for imperative paradigm, object-oriented paradigm and logic programming. Also, we shows an architecture that facilitates the teaching of programming languages by clarifying differences and commonalities of programming languages.

16:00 - 17:30
Fish-Bowl Panel Discussion on the Theme "State of the Art in OO Education— Benefits, Problems and Their Possible Solutions"

34 Developing Java Applications for Small Devices Using Eclipse

Monday, 27 October – 8:30-17:00 Full day

Chris Laffra, IBM Canada,
Michael van Meekeren, IBM Canada,

Eclipse is an increasingly popular Java-based open-source tooling platform. The platform provides support for Java program development, such as editing, compiling and debugging, and it is readily extensible through its plug-in mechanism. We have been involved in the development of a set of plug-ins that support the building and launching of embedded applications (with support for various platforms, such as J2ME/MIDP, PocketPC and PalmOS). We will show how applications can be developed, compiled, analyzed and compressed to fit on really small devices. We will demonstrate how to debug applications running in either an emulator or on a real device.

We will also discuss how these Eclipse plug-ins were developed, what trade-offs we encountered, and what lessons we learned, and we will offer suggestions that will benefit (future) Eclipse plug-in writers. The tutorial will also include a demonstration of writing an actual plug-in for Eclipse.

This technical tutorial will include lots of actual code and reports on practical experience. We will provide background information on developing Java applications for resource-constrained environments, such as PalmOS, and explain what Java standardization processes are under way in this area.

Attendee background

Prerequisites: Attendees must have basic experience with Java and any interactive development environment.


Lecture and demonstrations


Chris Laffra obtained his PhD at the Erasmus University of Rotterdam. At IBM Research, he worked on visualization of object-oriented programs. Then he worked at Morgan Stanley, a Wall Street investment bank, on user interface tool development, and component infrastructures. After returning to IBM Research, Chris worked on Java tools to enable program analysis, debugging, visualization, compression, and optimization. Chris led the OTI Amsterdam lab for 3.5 years and now works for IBM from its Ottawa lab, contributing to Eclipse-based development tools for embedded Java applications.

Michael Van Meekeren obtained his BCS from Acadia in 1994. He is a senior developer with IBM Ottawa labs (formerly known as Object Technology International), and has played an active role in the development of IBM Smalltalk, VisualAge for Java and WebSphere Studio Device Developer.

35 Essential Object-Oriented Analysis and Design

Monday, 27 October – 8:30-17:00 Full day

Jill Aden, EDS,
Joseph Brennan, EDS,

This tutorial is a short, quick-paced introduction to object-oriented analysis and design, based on practical project experience. It will provide you with the knowledge and skills to:

  • Create use case documents
  • Understand object-oriented concepts, terminology and buzzwords
  • Identify classes and create class diagrams
  • Understand and use the Unified Modeling Language (UML), identify behaviors and create sequence diagrams, and recognize other UML diagrams
  • Gain an understanding of what patterns are and review 5 of the "gang of four" design patterns

Attendee background

This tutorial is targeted to people who are new to objects and object-oriented concepts. It is intended for people who have had some exposure to objects but need more knowledge to be able to put all the pieces together.




Jill Aden has worked for 18 years with EDS as a Systems Architect and has worked with objects since 1993. She is a member of the OTUG group at the University of St. Thomas in St. Paul, MN and served as the Communications Chair at OOPSLA 2002. Ms. Aden is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, she mentors, consults, and teaches object-oriented concepts internally and externally to clients.

Joseph Brennan is a System Architect with EDS, where he has worked for 18 years. He is a member of the Twin Cities Java User Group and has been working with objects for 10 years. Mr. Brennan is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, Joseph mentors, consults, and teaches object-oriented development and concepts within EDS and externally to clients. Joseph is a Sun Certified Java Instructor and Java Developer.

36 Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects

Monday, 27 October – 8:30-17:00 Full day

Douglas Schmidt, Vanderbilt University,

Developing concurrent and networked object-oriented applications is hard; developing high-quality reusable components for these types of applications is even harder. The principles, methods, and skills required to develop reusable software cannot be learned by generalities. This tutorial, therefore, illustrates by example how to significantly simplify and enhance the development of communication software that effectively utilizes concurrency and distribution via the use of:

  • Object-oriented design techniques, such as patterns, layered modularity, and data/control abstraction
  • Object-oriented language features, such as abstract classes, inheritance, dynamic binding, and parameterized types
  • Middleware, such as object-oriented frameworks for host infrastructure middleware (e.g., ACE) and component middleware (like J2EE, the CORBA Component Model, and .NET)
  • Advanced operating system mechanisms, such as event demultiplexing, multi-threading, multi-processing, and explicit dynamic linking

The tutorial examines patterns and framework solutions abstracted from production systems in domains including from telecommunications, avionics, online trading systems, medical systems, web servers, and real-time object request brokers to illustrate the key technical design and implementation issues. The material presented in this tutorial is based on the book "Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects," Wiley & Sons, 2000.

Attendee background

Prerequisites: Participants must be familiar with object-oriented development techniques (such as patterns, modularity, and information hiding), OO language features (such as classes, inheritance, dynamic binding, and parameterized types), systems programming concepts (such as process/thread management, synchronization, and IPC), and networking terminology (such as client/server architectures and TCP/IP).




Dr. Douglas C. Schmidt is a Professor in the Electrical Engineering and Computer Science department at Vanderbilt University. His research focuses on patterns, optimization techniques, and empirical analyses of object-oriented frameworks that facilitate the development of distributed real-time and embedded (DRE) middleware. Dr. Schmidt has over fifteen years of experience developing DRE middleware as the chief architect and developer of ACE and TAO, which are widely used, open-source middleware containing a rich set of components that implement patterns for DRE systems. Dr. Schmidt has also served as a Deputy Director and a Program Manager at DARPA, where he led the national R&D effort on DRE middleware.

1 Reuse in Constrained Environments

Monday, 27 October – 8:30-17:00 Full day

Markus Voelter, independent consultant,
Michael Kircher, Siemens AG, Corporate Technology,
Christa Schwanninger, Siemens AG, Corporate Technology,
Uwe Zdun, New Media Lab, Vienna University of Economics and BA,
Alexander Schmid, Personal,

The main goals of software reuse are to increase quality, reduce cost, and shorten development cycles. The interesting question in this context is: How to achieve reuse in constrained environments? In desktop and enterprise systems, object-orientation, components, frameworks, service-oriented architectures and, most recently, model-driven development are proposed as cornerstones for efficient reuse. In constrained environments (i.e. embedded and real time systems, PDAs, smart phones, settop boxes) reuse is not as simple, because most reuse techniques imply some kind of overhead: memory, performance, or determinism.

This workshop explores practical reuse techniques for constrained environments. Potential topics include, but are not limited to:

  • middleware technologies
  • quality of service provisions
  • code composition and weaving
  • code generation, composition and weaving
  • small and efficient frameworks
  • component infrastructures for embedded systems
  • model driven development
  • static variability and metaprogramming
  • component composition
  • design and architectural patterns

3 Generative techniques in the context of MDA

Monday, 27 October – 8:30-17:00 Full day

Jorn Bettin, SoftMetaWare,
Ghica van Emde Boas, Software & Services,
Aditya Agrawal, Vanderbilt University,
Ed Willink, Thales Research,
Jean Bezivin, frUniversity of Nantes, France, Jean.Bezivin@sciences.univ-nantes

Model Driven Architecture (MDA) is an initiative by the OMG to leverage UML-based modeling techniques to insulate abstract software system specifications from implementation dependencies. The workshop focuses on generative techniques that can be used to realize MDA. We aim to bring together practitioners, researchers, academics, and students to discuss the state-of-the-art of generative techniques in the context of MDA. The OOPSLA'02 workshop on this topic was highly successful and led to the launch of the Generative Model Transformer (GMT) open source initiative.

Topics of interest include:

  • synergy between MDA, components and generative techniques;
  • implementing domain specific languages on the basis of the UML [2.0] Infrastructure;
  • modeling variability in functionality within product lines;
  • notations for model-to-model transformations;
  • model weaving and model transformation;
  • pre and post-conditions for transformations;
  • transformation and traceability;
  • organization of hierarchical transformation libraries; transformations as assets;
  • applications of higher level transformations (transformations generating transformations);
  • verification of transformation systems;
  • a possible definition of a common standard notation for model transformation within the context of the MDA;
  • styles of model-driven generators;
  • model-driven template languages (language design, template execution environment, debugging, template editors, management of template code);
  • specification of heuristics and manual design decisions
  • use of XSLT, XQuery and other similar tools for MDA;
  • generation of code and non-code artifacts (e.g. tests, measures, etc.);
  • influence of MDA on software architecture;
  • MDA and agile development;
  • industrial applications of MDA.

The goal is to share experience, consolidate successful techniques, and identify the most promising application areas and open issues for future work.

4 Agile Contracts

Monday, 27 October – 8:30-17:00 Full day

Mary Poppendieck, Poppendieck.LLC,
Ken Schwaber, Advanced Development Methods, Inc.,
Tom Poppendieck, Poppendieck.LLC,

Agile Contracts. Are these two words an oxymoron? Contracts have played a very important role in the business of software development; in fact, much of this work is in fact done 'under contract'. Organizations adopting agile methodologies are finding it hard to write contracts for software development without compromising the core values and practices. The Agile Contracts workshop is your chance to help the agile community identify ways contracts can be structured and worded to support agile software development.

Come prepared to participate! Come and participate in the discussion about how to structure agile software development contracts and take away many great ideas, no matter which side of a software development contract you find yourself.

"I learned more from this workshop than from any other session," said one Agile Contracts Workshop participant at XP 2003. Use gaming theory to understand the motivations of contracting parties. Share examples of a contract structure, which had either good or bad effects on agile software development. Work with a small team to devise a contracting strategy, which supports agile software development.

Leave a Legacy. The good ideas generated in this workshop will be posted to the web for all to see.

5 The Twelfth OOPSLA Workshop on Behavioral Semantics— Striving for Simplicity

Monday, 27 October – 8:30-17:00 Full day

Haim Kilov, Independent Consultant and Stevens Institute of Technology,
Kenneth Baclawski, Northeastern University,

The goal of this workshop is to foster precise, explicit, and elegant OO specifications of business and system semantics, independently of any (possible) realization. Substantial progress has been made in these areas, both in academia and in industry. However, in too many cases only lip service to semantic issues has been provided, and as a result the systems we build or buy are all too often excessively complex or (this is not an exclusive or) are not what they are supposed to be. Doing better than that requires both a clear understanding of the problem semantics within the context of their business and technological environments, and an abstract, precise and explicit specification of that semantics.

The specific theme this year is on striving for simplicity. In order to simplify IT systems, we need to use abstraction — in C.A.R.Hoare's words, "only abstraction enables a manager or a chief programmer to exert real technical control". The same considerations apply to understanding, modeling and making (strategic, tactical and operational) decisions about businesses.

8 Multiple Viewpoints for System Modeling

Monday, 27 October – 8:30-17:00 Full day

Fred Cummins, EDS,
Cory Casanave, Data Access Technologies,
William Frank, Domain Architects,
Stan Hendryx, Hendryx Associates,
Steven Mellor, Project Technology,
Joaquin Miller, Domain architects,

UML (Unified Modeling Language) has been widely accepted by the industry as the lingua franca for modeling object-oriented applications. In recent years, UML profiles such as the Common Warehouse Metamodel (CWM), the UML Profile for Enterprise Distributed Object Computing (EDOC) and the UML Profile for Enterprise Application Integration have defined specialized modeling languages for particular problems. The ISO Reference Model for Open Distributed Processing (RM-ODP) calls for systems to be designed with multiple viewpoints. These viewpoints represent different abstractions and might be implemented as different modeling languages for expression of the particular concepts and relationships relevant to the point of view. These languages should be integrated or otherwise reconciled to achieve a consistent overall system design.

The purpose of this workshop is to explore the characteristics of models of information systems that address areas of concern beyond the structure of programs, and to consider the implications of integrating such models to develop a comprehensive, consistent model of a system.

10 Pervasive Computing; going beyond Internet for small screens

Monday, 27 October – 8:30-17:00 Full day

Steffen Schaefer, IBM Global Services,
Rob van den Berg, Siemens,
Steve Marney, EDS,

Pervasive Computing has become a reality and is further emerging. And even though Pervasive Computing is still in its infancy, no one can deny its potential to change how we live and do business. Pervasive Computing is pointing toward a future in which the networking web will be extended to an ever larger number of players, to smaller machines, houses, appliances, etc., which are increasingly becoming more intelligent. Applications and architectures are becoming multi modal and aware of their context. This web will allow machines to interact with other machines and humans. The sheer number of players interacting with each other and their penetration in our daily lives, such as household appliances, is going to make the impact even more formidable.

In some respects, pervasive solutions contain many elements from standard e-Business systems and are implemented with the same or similar technology. However, the combination of the pervasiveness of computing functionality and internet access, together with possibilities such as the remote monitoring of events and pushing information to users and machines, or the creation of location-aware services, is a new paradigm. Clearly, the well-known Web 'Request/Response' model, as implemented through WAP or i-mode is not enough. Disconnected Work, Intelligent Notification, Ad Hoc Networks, and Data Replication are just a few samples usage patterns where Pervasive Computing goes beyond 'internet for small screens'.

We believe Object Technology is playing a major part in shaping up this new computing paradigm. In some ways, objects can be regarded as becoming highly dynamic and more pervasive, 'living' on even the smallest device. The computing model is becoming even more distributed, possibly using Web Services as the prime means for cooperation.

workshop will bring together practitioners who have been actively involved in the development of Pervasive Computing solutions, researchers who have been working in this area, and people who have been involved in the definition of standards. The goal is to identify recurring architecture themes and patterns typically used to build such systems, or raise issues and gaps for implementation that need to be resolved.

The workshop is a sequel to similar sessions from the previous years at OOPSLA. It will start off with a short presentation of accepted papers and will then be highly interactive, aiming for tangible outcomes, such as sketches of reference architectures or patterns identified in this field.

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

Monday, 27 October – 8:30-17:00 Full day

Dennis Mancl, Lucent Technologies - Bell Labs,
William Opdyke, North Central College,
Steven Fraser, Consultant,
Willem-Jan van den Heuvel, Infolab Tilburg University,

Reengineering and evolution are important for long-lived software systems. Change and growth in the system's requirements and functionality occur in all kinds of systems — and it is especially critical to manage the evolution process in modern agile and extreme software processes. The management of change and growth may in fact become a daily activity, so a well defined set of techniques and tools for doing reengineering are critical to success.

This workshop picks up from the results of the OOPSLA '02 workshop "Tackling the Discovery Costs of Evolving Software Systems."

Participants will present and discuss encapsulation and reverse engineering techniques, impact of reengineering on software processes, organizational concerns, and experiences in managing software change "in the extreme".

14 Semantics of Enterprise Integration III

Monday, 27 October – 8:30-17:00 Full day

Mark Lycett, Brunel University (UK),
Sergio de Cesare, Brunel University (UK),
Guido Geerts, University of Delaware (USA),
Grant Holland, Sun Microsystems (USA),
Chris Partridge, Brunel University, UK,

Semantics underlie the fundamental problems that business stakeholders and system developers constantly cope with when integrating enterprise systems. Well-known issues, such as semantics description, expression of common semantics across systems and interoperability of data and processes, are amplified in the enterprise arena. Enterprise integration, although related to it, is not synonymous to technical systems integration. More complex forms of communication and coordination are required and encompass the multifaceted dimensions of the business (i.e., technical, organizational and human).

The importance of identifying ways to define, model and express semantics at a business level is highlighted by the growing importance of the application of ontologies to the development and re-engineering of enterprise systems. Also semantics is driving emerging technologies such as the semantic web, GRID systems and web services.

This workshop is aimed at bringing together researchers and practitioners with diverse cultural and professional backgrounds in order to discuss and analyze the different semantic issues and perspectives of enterprise integration.

Keywords: enterprise/systems integration, semantics, ontology, services.

18 Bridging the Gap: Examining Approaches that Connect Business Requirements to Enabling Technology Solutions

Monday, 27 October – 8:30-17:00 Full day

Ralph Hodgson, TopQuadrant, Inc.,
Dave Parrish, Management Science Associates, Inc.,
Christine Brautigam, Direct Dynamics, Inc.,
Dr. Robert F. Coyne, TopQuadrant, Inc.,

To ensure return on technology investments, companies need to align IT projects to their Business Strategy. Today a technology solution has many stakeholders, requiring systems to be developed in a multi-stakeholder context.

The key stakeholders include:

  • End-users of the solution who will have to live with the solution and will ultimately decide how successful it is – often they are external customers of the company
  • The Enterprise that is hoping to realize a business ROI from the solution
  • IT departments or other technical organizations responsible for implementing the solution
  • Technology vendors whose technology provides underpinnings and components of the solution

Stakeholders often have conflicting objectives. Moreover, differing sub-cultures and ways of working and communicating contribute to communication barriers and the possibility of project failure.

This workshop explores ways of realizing an effective “bridge” to close communication gaps and to create a shared vision and plan for realization among different stakeholders. The benefits of having an effective way to translate a Business Strategy into optimal technology solutions include:

  • Improved likelihood of project success
  • Increased enterprise vitality through effective use of technology
  • Greater ROI of technology spending

The workshop will look into approaches for accelerated solution design that can reliably translate and connect core business requirements into the best choices for enabling technology and software implementations. In particular, the workshop will solicit submissions that summarize substantive candidates of such approaches for presentation and subsequent cross-comparison and analysis. Workshop attendees will discuss, analyze and attempt to distill the essence of what makes these approaches work – looking for a core set of similar features, activities, constructs and results produced that have proven to be effective and reliable.

One possible example of such a common feature -- the use of solution stories -- appears to foster a common understanding of ideas and confidence in proposed capabilities for given domains. As one of the probable items of focus, the workshop will seek to confirm that this is a common feature, and to understand why. The overall goal and result of the workshop will be to catalog the most important, common features or activities of the best approaches and how and why each works, whether by itself or in combination with the rest.

19 Eclipse Technology eXchange

Monday, 27 October – 8:30-17:00 Full day

Michael Burke, IBM TJ Watson Research Center,
Erich Gamma, IBM Object Technology International, Zurich,
Gabby Silberman, IBM Center for Advanced Studies,
Mary Lou Soffa, Pittsburgh University,

The eclipse platform ( is designed for building integrated development environments (IDEs) for object-oriented application development. The eclipse Technology eXchange workshop will feature presentations of about 12 papers that describe the use of the eclipse open source as a code base for teaching and research, or for support of a community service. The presenters will report on their projects and explore potential new uses of eclipse and improved usability of the core eclipse technology. Technical leaders of the eclipse community will be available throughout the workshop to answer questions and participate in the technology exchange.

keywords: object-oriented programming, integrated development environment

See the call for papers and other information:

21 2nd International Workshop on Language Agnostic Runtimes and Component Based Architectures

Monday, 27 October – 8:30-17:00 Full day

Yahya Mirza, Aurora Borealis Software,
David Simmons, Smallscript LLC,
Mario Wolczko, Sun Microsystems,
Shawn Woods, Microsoft,

The objective of this workshop is to have a detailed technical discussion on requirements for future virtual machines and advanced languages from an applications perspective.

Issues such as what features and their virtual machine implementations actually promote object reuse. What has worked in the past? Has the original design goals of the respective participants in their respective object architectures been met. What problems were encountered during the commercial deployment of their respective architectures? What do the participants see as the direction they believe that virtual machine technology will take in the near future, as well as over the long haul?

22 Web Services and Service-Oriented Architecture Best Practices and Patterns

Monday, 27 October – 8:30-17:00 Full day

Ali Arsanjani, IBM Corporation,
Kerrie Holley, IBM,

Web services and service-oriented architectures are promising technology. However, they are still fraught with problems and issues: operational issues, quality of service, functional and methodology related.

In this workshop we aim to identify real industry experiences (successes or failures) in designing and implementing web services based systems. And we look for research papers aiming at identifying and alleviating major bottlenecks and issues related to service-oriented architectures, web services and dynamically re-configurable architectures.

This workshop builds on the Object Oriented Web Services workshops in previous OOPSLA conferences and sets a slightly different direction, aimed at consolidating web services and service-oriented architecture best practices and patterns.

20 The C# Programming Language

Monday, 27 October – 8:30-12:00 Morning

Anders Hejlsberg, Microsoft Corporation,

This tutorial gives an in-depth overview of the C# programming language, both as it currently exists and as it is planned to evolve in the near future. An emphasis will be placed on explaining design rationales, making the talk interesting for both programmers and language designers.

Attendee background

Prerequisites: Participants should have a good working knowledge of object-oriented programming. Previous experience with C# and .NET is not required.


Lecture and working code demonstrations


Anders Hejlsberg is a Distinguished Engineer in the Developer Division at Microsoft Corporation. He is the chief designer of the C# programming language and a key participant in the development of the .NET Framework. Before joining Microsoft in 1996, Anders was a Principal Engineer at Borland International. As one of the first employees of Borland, he was the original author of Turbo Pascal and later worked as the Chief Architect of the Delphi product line. Anders studied Engineering at the Technical University of Denmark.

22 Garbage Collection

Monday, 27 October – 8:30-12:00 Morning

Richard Jones, University of Kent at Canterbury,
Eric Jul, University of Copenhagen,

This tutorial presents the issues facing modern high-performance garbage collectors and examines the approaches taken by state-of-the-art garbage collectors.

Participants will gain a deeper insight into the operation of modern, high-performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of such garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors.

Attendee background

Prerequisites: Participants must be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential.


Lecture, animations, and demonstrations


Richard Jones is a Senior Lecturer and Deputy Director of the Computing Laboratory at the University of Kent. He is the prime author of the book on Garbage Collection. His interests include programming languages and their implementation and visualisation, storage management and distributed systems. He is Coordinator of the UK Memory Management Network of researchers, a member of the Steering Committee of the International Symposium on Memory Management and was Programme Chair for ISMM'98. He has presented several tutorials at OOPSLA and ECOOP.

Eric Jul is a Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he leads research in distributed, heterogeneous computing. He is co-designer and principal implementer of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPLSA conferences he has run a number of workshops and tutorials related to distributed computing and memory management. He was Programme Chair for ECOOP'98.

23 Beyond the Gang of Four

Monday, 27 October – 8:30-12:00 Morning

Frank Buschmann, Siemens AG, Corporate Technology,
Kevlin Henney, Curbralan Ltd.,

When software developers mention design patterns, the chances are that they are talking about Design Patterns, the classic book by the Gang of Four, rather than design patterns in general. Even when they are talking about the pattern concept, as opposed to specific patterns, they often think in terms of the form and idea presented in GoF, and rarely beyond.

Since the publication of the seminal work by the GoF in 1994, however, a great deal of research and practice in patterns has led to a better understanding of both the pattern concept and the strengths and weaknesses of the GoF patterns themselves.

This tutorial revisits the GoF patterns, reflects on them, deconstructs them, and re-evaluates them from the practitioner's perspective: why patterns such as Abstract Factory, Builder, Flyweight, Command, and others are missing a vital ingredient to be proper parts of an architectural vocabulary; why Iterator is not always the best solution for traversing aggregates; why State is not the only state pattern; why some patterns, such as Bridge, are more than one pattern; and what you can do about it.

Attendee background

Prerequisites: Sound knowledge of the pattern concept and the GoF patterns are required.


Interactive lecture


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

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.

24 Patterns of Enterprise Application Architecture

Monday, 27 October – 8:30-12:00 Morning

Martin Fowler, ThoughtWorks,

The last decade or so has been one of technology churn. We've seen client/server, CORBA, J2EE, COM, .NET and a host of other enterprise platforms appear or fade from view, or both. Keeping up with resulting alphabet soup is a full time job, even without applications to ship.

But amongst all of this churn, some techniques stay relatively constant. So we've been trying to identify these common patterns and taking note of how we use the ideas from one technology and use similar, but not the same designs in others.

In this tutorial, we'll explore a number of these patterns. We will touch on various topics, including layering, business logic organization, database mapping, organizing a web interface and the allure of distributed objects.

The tutorial is based on the author's book, "Patterns of Enterprise Application Architecture."

Attendee background

Prerequisites: Participants must be familiar with the basics of object-oriented development in an enterprise setting.




Martin Fowler is the Chief Scientist of ThoughtWorks, a systems delivery and consulting firm. He has pioneered the use of object-oriented technology in enterprise applications and has written five books on software development.

25 Agile Requirements Specification

Monday, 27 October – 8:30-12:00 Morning

Jennitta Andrea, ClearStream Consulting Inc.,
Gerard Meszaros, ClearStream Consulting Inc.,

XP advocates streamlining the requirements specification activity process, to the extent that conversations and automated tests replace thick, formal, and invariably incomplete/outdated requirements documents. The dials are turned to the maximum settings, resulting in maximum agility. There are most certainly situations where this approach is a perfect fit. But what about situations where this approach is not possible (e.g. distributed teams, safety critical systems, etc)? If we fiddle with the settings of some of the dials, will the end result still be agile?

This tutorial explores strategies for tuning the requirements process to optimize agility for a given set of project factors (e.g. team size, project complexity, project criticality, team knowledge and experience, stability and completeness of requirements, etc). Topics discussed include: What work products do we need to use? How much detail is required? How formal does the communication channel need to be? How formal does the notation need to be? What kinds of tools do we need to use? What is the impact of unexpected change?

Attendee background

This tutorial is targeted to developers, managers, analysts, and "customers."

Prerequisites: Knowledge of common requirements artifacts such as use cases and UML notation (use case diagrams, activity diagrams, state transition diagrams, class diagrams) is beneficial but not required. This tutorial focuses on the application of more general concepts and not the specifics on any one set of requirements artifacts.


This tutorial is extremely interactive (definitely not "death by PowerPoint"). Simulation exercises provide participants with first hand experience and rapid feedback on various approaches to requirements specification. Guided group discussions following each simulation enable the sharing of insights and facilitate a deep and lasting understanding of the underlying concepts.


Jennitta has been a senior consultant with ClearStream Consulting since 1994 as process mentor, OO developer, requirements analyst, business modeler, instructor, and retrospective facilitator. Jennitta has been a practitioner of XP since 2000 in a variety of capacities: developer, mentor, and writer/speaker ("Managing the Bootstrap Story," XP 2001, "Catalog of XP Project Smells," XP 2002, and "Framework XP," XP 2002). Jennitta is an experienced instructor; she has recently co-developed and delivered multiple sessions of a three-day course on automated testing for developers and a three-day workshop on agile requirements specification.

Gerard is Chief Scientist at ClearStream Consulting, where he leads teams applying agile software development techniques (such as eXtreme Programming) to help ClearStream's clients achieve faster and higher quality application development. He has presented successful tutorials at the past four OOPSLAs and has presented papers on automated testing and developing object oriented software frameworks at past XP and OOPSLA conferences.

26 Patterns for High Performance Systems

Monday, 27 October – 8:30-12:00 Morning

Robert Hanmer, Lucent Technologies,

Good performance, reliability, and maintainability are designed into software. The tutorial presents a guided tour through existing, industry-tested patterns that aid in the design of high performance, real-time, distributed and embedded systems, using a telecommunications system to structure the tour. The tour highlights various collections of patterns, as well as their sources -- books, conference notes and websites. Our objective is to make participants aware of these valuable resources that can greatly simplify their design work. By reusing a proven solution to frequently occurring problems, their efforts can be focused on the truly new portions of their design.

Attendee background

Prerequisites: Attendees should have a basic understanding of what a pattern is. No prior knowledge in any specific domain is expected. Attendees will gain the most from the tutorial if they have considered the general performance and reliability constraints with which they most frequently work.




Robert Hanmer is a Consulting Member of Technical Staff in the Convergence Solutions R&D organization of Lucent Technologies. He began working with patterns in 1995, capturing the patterns of a large telephone switching system and also of telecommunications systems in general. He has served as Program Chair at several PLoP conferences. He is active in the Hillside Group, as well as the TelePLoP group, which is an informal collection of pattern advocates and authors interested in the field of telecommunications. He has authored many patterns that discuss key solutions for high performance systems.

29 Foundations of Object-Oriented Languages: Types and Language Design

Monday, 27 October – 8:30-12:00 Morning

Kim Bruce, Williams College,

Static typing aids in earlier error detection, supports compiler optimizations, and provides information to programmers on the intended use of constructs. However, simple static-typing disciplines for object-oriented languages like C++ and Java are so restrictive that programmers are forced to bypass the type system with type casts. Other languages allow more freedom, but require run-time checking to pick up the type errors that their more permissive systems missed.

After surveying problems with existing type systems (illustrated by a series of sample programs), we explain contravariance and covariance issues in type systems, and suggest ways of improving the expressiveness of these systems while retaining static type safety. Constructs introduced include "MyType," "matching," and "F-bounded polymorphism." We include a brief discussion on how the type system and semantics ensure type safety. We apply the concepts in the tutorial to compare the strengths and weaknesses of proposals to extend Java to support genericity based on F-bounded polymorphism, "where" clauses, match-bounded polymorphism, and virtual types. In particular, we cover the advantages and disadvantages of the forthcoming extensions to Java (taken from GJ) to support parametric polymorphism.

Attendee background

Prerequisites: Attendees should be very comfortable with a class-based object-oriented programming languages. Ideally, the attendee should have sufficient experience with type systems as to be frustrated with their limitations.




Kim Bruce is Wells Professor of Computer Science at Williams College. He received his Ph.D. from the University of Wisconsin and has been a visiting professor or scientist at M.I.T., Stanford, and Princeton, among others. A researcher on the types and semantics of object-oriented languages, he has served twice on the OOPSLA program committee, on the program committee of POPL '03, and as chair of the organizing committee of the FOOL workshops on the Foundations of Object-Oriented Languages for many years. He has presented papers at the ECOOP, OOPSLA, and POPL conferences, and is the author of the book, "Foundations of Object-Oriented Languages: Types and Semantics," MIT Press, 2002.

27 Java Reflection

Monday, 27 October – 13:30-17:00 Afternoon

Ira Forman, IBM,
Nate Forman, Ticom Geomatics,

Reflection can help to improve productivity by promoting the development of programs that are easily adapted to requirements changes. Reflection facilitates testing and problem determination by permitting the automation of more tedious tasks. In general, reflection improves the flexibility, extensibility, and reusability of code.

The Java programming language (version 1.4) contains a highly effective reflection facility. This tutorial explains the concept of reflection, the Java metaobjects (including both introspective and intercessional interfaces), the proxy class, and dynamic compilation and class loading. The limits of Java reflection are addressed in the context of what reflection is capable of in general. In addition, the tutorial demonstrates the efficacy of the Java reflection facility for solving practical problems. Such problems include: program/application testing, generation of code, inspection of code, and use of dynamic class loading in a framework for application extension. Finally, we will cover the performance impact of using reflection.

This tutorial is the basis of a book titled "Java Reflection" to be published by Manning Publications.

Attendee background

Prerequisites: Attendees must be competent Java programmers.




Dr. Ira R. Forman works for IBM in Austin. As a member of IBM's Object Technology Products Group, which produced the SOMobjects Toolkit, he worked on the SOM Metaclass Framework. From 1984 to 1991, he worked on distributed systems design in the MCC Software Technology Program. He started working in the area of object-oriented programming in 1982 at the ITT. Dr. Forman received his Ph.D. in Computer Science from the University of Maryland, where he studied under Harlan Mills. His specialties are object-oriented programming, distributed systems, and object composition. He is the coauthor of two books: "Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming" and "Putting Metaclasses to Work: A New Dimension in Object-Oriented Programming."

Nate Forman works for Ticom Geomatics where he designs and programs application frameworks for their products. His specialties are patterns and object-oriented programming. Forman holds a MSE in Software Engineering from the University of Texas at Austin and a BS in Computer Science from the College of Engineering at Cornell University.

28 Enterprise Integration Patterns

Monday, 27 October – 13:30-17:00 Afternoon

Bobby Woolf, Independent Consultant,
Gregor Hohpe, ThoughtWorks, Inc.,

It's no longer enough to be able to develop fantastic applications; now they have to be able to coordinate with each other as well. Whether your sales application must interface with your inventory application, your procurement application must integrate with an auction site, or your PDAs PIM must synchronize with the corporate calendar server, just about any application can be made better by integrating it with other applications. Customers expect an integrated, single-application experience, regardless of how internal functionality may be split across applications, so applications must be integrated.

This tutorial will teach you how to use messaging to integrate applications effectively by presenting a set of patterns--best practices that have been proven over time in a variety of integration projects. These patterns will teach you how to use message-based communication successfully.

This tutorial is based on technology-agnostic patterns and applies to a variety of messaging technologies, ranging from the Java Message Service (JMS) API in J2EE, and the System.Messaging namespace in Microsoft .NET, to enterprise application integration (EAI) and middleware products from vendors such as IBM, TIBCO, WebMethods, SeeBeyond, Vitria and others.

Attendee background

This tutorial is intended for enterprise application architects, designers, and developers who have basic familiarity with messaging tools and technologies, but wish to learn how best to use messaging to achieve enterprise application integration, and wish to be able to better communicate about these issues.

Prerequisites: Basic familiarity with messaging tools and technologies.




Bobby Woolf has been developing multi-tier object-oriented business applications for thirteen years using Java/J2EE, Smalltalk, and embedded systems for messaging, workflow, business rules, and persistence. One of his specialties is developing architectures that integrate workflow, EJB, and JMS. He has presented tutorials at OOPSLA and JavaEdge, published articles in Java Developer's Journal and on the DeveloperWorks web site, published patterns in all of the PLoPD books, and is a co-author of The Design Patterns Smalltalk Companion. He is also a co-author of the upcoming book "Enterprise Integration Patterns" from Addison-Wesley.

Gregor Hohpe leads the Enterprise Integration Services competency at ThoughtWorks, Inc., a provider of application development and integration services. Over the past years, he has been helping clients around the globe design and implement enterprise integration solutions. His current work focuses on the application of agile methods and design patterns to the development of integration solutions. Gregor is a frequent speaker at technical conferences and has published a number of articles presenting a no-hype view on enterprise integration, Web services and Service-Oriented Architectures. He is a co-author of the upcoming book "Enterprise Integration Patterns."

30 Large-Scale Software Architecture: A Practical Guide Using UML

Monday, 27 October – 13:30-17:00 Afternoon

Jeff Garland, CrystalClear Software,
Richard Anthony, General Dynamics Decision Systems,

Dealing with the complexity of large-scale systems can be a challenge for even the most experienced software designers and developers. Large software systems can contain millions of elements, which interact to achieve the system functionality. Managing and representing the complexity involved in the interaction of these elements is a difficult task.

This tutorial will help you manage this complexity through the use of industry-proven software architecture approaches, based on the UML and IEEE 1471 standards. We will introduce software architecture terminology and approaches, focusing on a set of UML viewpoints that represent the important aspects of a large-scale software architecture. These viewpoints include context, component, subsystems, process and deployment. These viewpoints leverage the recent IEEE 1471 standard for software architecture representations providing a description of the purpose, stakeholders, and techniques associated with each viewpoint.

The tutorial also presents other practical techniques essential to developing an effective software architecture. Topics covered in the tutorial include:

  • Techniques for handling large, complex systems
  • Modeling of software subsystem interfaces and dependencies
  • Modeling of components, component interactions, and component integration
  • Modeling of process communication and software/hardware deployment
  • Fitting architecture development into development processes

Attendee background

Prerequisites: Attendees must have a basic understanding of UML, have experience as a software developer, and an interest in software architecture. Experience on a large-scale software system is beneficial but not required.


Lecture and discussion


Jeff Garland has worked on many large-scale software projects over the past 16 years, and in many different domains, including telephone switching, industrial process control, satellite ground control, and financial systems. He has served as both the lead architect and a member of the architecture team on several of these projects. Mr. Garland holds a Master's degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is currently President and Chief Technology Officer of CrystalClear Software. CrystalClear Software is a consulting firm that specializes in the development of software architectures for large-scale systems.

Richard Anthony has l7 years experience working on large-scale software development efforts. The systems are from application areas such as satellite and network operations systems, telephony base station control, manufacturing, and simulation. He has served in the role of chief software architect, design engineering technical lead, software design lead, software system engineer, and developer on projects in these application areas. Mr. Anthony holds Master's degrees in Computer Science and Mathematics, as well as a Bachelor's degree in Mathematics Education, all from the University of Wyoming. He is currently a Senior Software Architect at General Dynamics Decision Systems.

31 Technical Leadership In Practice

Monday, 27 October – 13:30-17:00 Afternoon

Andrew Schneider, BJSS (,

So you're a technical lead. You will have to combine many disparate skills to achieve that elusive goal, the successful team. Project management, people management, requirements management, as well as good design and implementation skills, are all core ingredients. This tutorial examines techniques and patterns for being a successful technical lead. Key areas covered include:

  • Becoming a technical lead (leadership styles, winning respect etc).
  • Project initiation--laying down the foundations, selecting a method.
  • Getting decisions adopted and socialised.
  • Targeted design and architecture.
  • Transparent design.
  • Managing upwards--metrics, monitoring progress, etc.
  • Handling personnel problems.
  • Handling a project in crisis.
  • Worry Patterns--signs not to be ignored.

...and more. A recent project will be used to illustrate the application of the techniques "in the wild." During the tutorial, there will be time to share experiences, discuss problems and consider other solutions. Participants will leave with a comprehensive set of references.

Attendee background

Participants will be either new to technical leadership or already have been in a technical lead role for some time and wish to share experiences and learn some new techniques.


Lecture, group discussion, and copious real world examples


Andy Schneider wears consultant and architect hats for BJSS, a software services organisation. He has been involved in implementing, designing and leading projects utilising object-oriented technology since 1990. His primary interests are complex distributed systems, security and technical management. When wearing his consultant hat, he finds himself performing presentations and tutorials on a regular basis.

32 Domain-Driven Design

Monday, 27 October – 13:30-17:00 Afternoon

Eric Evans, Domain Language, Inc.,
Ralph Johnson, University of Illinois,

Large information systems need a domain model. Development teams know this, yet they often end up with little more than data schemas. This tutorial delves into how a team, developers and domain experts together, can engage in progressively deeper exploration of their problem domain while making that understanding tangible as a practical software design. This model is not just a diagram or an analysis artifact. It provides the very foundation of the design, the driving force of analysis, even the basis of the language spoken on the project.

The tutorial will focus on three topics:

  1. The conscious use of language on the project to refine and communicate models and strengthen the connection with the implementation.
  2. A subtly different style of refactoring aimed at deepening model insight, in addition to making technical improvements to the code.
  3. A brief look at strategic design, which is crucial to larger projects. These are the decisions where design and politics often intersect.

The tutorial will include group reading and discussion of selected patterns from the book "Domain-Driven Design," Addison-Wesley 2003, and reenactments of domain modeling scenarios.

Attendee background

Prerequisites: Attendees must have a basic understanding of object-oriented modeling and the ability to read UML. Some involvement, past or present, in a complex software development project is helpful in seeing the applicability of the material, but is not essential. Familiarity with the practices of Agile Methods and/or Extreme Programming is helpful, but not essential.


Interactive reading/discussion session, and simulations of the activities and processes that go into making domain design decisions.


Eric Evans is a specialist in domain modeling and design in large business systems. Since the early 1990s, he has worked on many projects developing large business systems with objects and, since 1999, has been deeply involved in three projects committed to the Extreme Programming process (XP), and has trained teams in the Extreme Programming process. Out of this range of experiences have emerged the synthesis of principles and techniques shared in the book "Domain-Driven Design," Addison-Wesley 2003.

Ralph Johnson is a co-author of the now-legendary book, "Design Patterns" (Addison-Wesley, 1995). He is on the faculty of the Department of Computer Science at the University of Illinois. He is the leader of the UIUC patterns/Software Architecture Group and the coordinator of the senior projects program for the department. His professional interests cover nearly all things object-oriented, especially frameworks, patterns, business objects, Smalltalk, COM and refactoring.

33 From Component Reuse to Asset-Based Software Engineering

Monday, 27 October – 13:30-17:00 Afternoon

Martin Griss, Martin Griss Associates,

This tutorial presents an introduction to the interlocking business, organizational and technical issues that influence large-scale software reuse and asset-based software engineering. Asset reuse is one of the most significant enablers for productivity improvements; it appears simple at first glance, yet is difficult to execute. Most organizations do not know how to effectively structure a reuse program to match their business and software goals. We describe three primary flavors of reuse: Facilitated, Managed and Designed. An organization selects and practices one or more of these flavors of reuse by varying the amount of proactive management of assets and process; proactive design and architecture of assets to enhance reuse, and amount of top-down, pre-work, versus bottom up incremental reengineering. Particularly important is how it encourages or enforces use of these assets, how it invests in the people, process and technology to support the reuse program, and how it structures and manages the organization to provide, support and utilize the assets. Topics covered include: Business and economic issues; reuse experience; flavors of reuse; architecture, components, frameworks and product lines; reuse process and design methods, domain engineering; reuse governance and organization; and technology and tools such as templates, aspects, generators and repositories.

Attendee background

Prerequisites: This tutorial is geared towards managers, architects and senior developers who have some software engineering, programming and modeling experience, and who are eager to establish or refine an asset reuse program.


Lecture and interactive discussion


Martin Griss is one of the world's leading authorities on software reuse. He spent nearly two decades as Principal Laboratory Scientist and Laboratory Director at Hewlett-Packard Laboratories. Known as HP's "Reuse Rabbi," he created and led a corporate-wide software reuse program. His research has covered software reuse processes and tools, software engineering tools and methods, and software agents. He is co-author of "Software Reuse: Architecture, Process and Organization for Business Success," and author of over 60 book chapters, papers, columns and reports. He is an Adjunct Professor of Computer Science at the University of California at Santa Cruz, a consultant, and member of Flashline's Software Development Productivity Council.

42 Agile Use Cases

Monday, 27 October – 13:30-17:00 Afternoon

Alistair Cockburn, Humans and Technology,

Some people consider use cases and agile development to be contradictory concepts, writing use cases as mere replacements for whatever requirements documents they were writing on their all-requirements-first, document-centric projects. Alistair Cockburn, one of the few people expert in both use cases and agile development, will review how to work with use cases on those other projects, where you choose to spend less time on documentation, do it later, need to save money, or plan on changing your mind along the way.

Part of the secret is in writing less, more clearly. The tutorial will include tips for structuring use cases to take less time to write, becoming both shorter and clearer, siphoning less time from project progress, and communicating crucial information more quickly. Part of the secret lies in knowing what parts to omit and when to omit them. The tutorial will include tips for shortcutting both the process and the use case structure for those projects that choose those tradeoffs. Not much can be said about tools, but what is known about setting up tools for agile use cases will be addressed. Along the way, the tutorial will review the fundamentals of both use cases and agile development, addressing particularly the basic structure and common misconceptions surrounding each. The presenter will allocate time within the session to answer arbitrary questions that the curious attendee might bring along.

Attendee background

This tutorial is intended for people who are curious about agile development, or those familiar with agile development and skeptical about adopting use cases.

Prerequisites: Some previous exposure to use cases is required. No special knowledge of agile development is needed.


Lecture and discussion


Dr. Cockburn is a highly-regarded instructor and is known as one of the premier experts on use cases as well as one of the authors of the Manifesto for Agile Software Development. His book "Writing Effective Use Cases" set the standard in the area. That and his "Agile Software Development" both received the Jolt Productivity book awards in 2001 and 2002, respectively. Dr. Cockburn has taught use case writing since 1994, and has also acted as consultant on project management, object-oriented design, and methodology to the Central Bank of Norway, the IBM Consulting Group, and the First Rand Bank of South Africa. Materials that support his workshops can be found at

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,

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,

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,
Kenneth Baclawski, College of Computer Science, Northeastern University,

Elegant OO specifications of business and system semantics

Visualizing Class Interfaces with Concept Lattices

Uri Dekel, ISRI, School of Computer Science, Carnegie Mellon University,
Yossi Gil, CS Dept, Technion, Israel,

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,
Jeff Hoare, SoftMetaWare,

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,
Paul Brebner, CSIRO, Australia,
Emmanuel Cecchet, INRIA Rhone-Alpes, France,
Julie Marguerite, INRIA Rhone-Alpes, France,

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,

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,
Jonathan Schifman, University of the Pacific, Department of Computer Science,

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,
Ghica van Emde Boas, Bronstee Software & Services,

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,
Dennis Mickunas, Department of Computer Science, University of Illinois at Urbana-Champaign,

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.,
David Janzen, Bethel College,

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,
Karl Michael Göschka, Frequentis Nachrichtentechnik GmbH,

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,

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,
Carlos Lucena, Pontifical Catholic University,

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,
Laurie Hendren, McGill University,
Clark Verbrugge, McGill University,

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,
William Opdyke, North Central College, Naperville, IL,
Steven Fraser, Consultant, Santa Clara, CA,
Willem-Jan van den Heuvel, InfoLab, Tilburg University, Tilburg, The Netherlands,

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,
Mohamed Fayad, San José State University,

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,
Ahmed Mahdy, University of Nebraska-Lincoln,
Mohamed Fayad, San José State University,
Marshall Cline, MT Systems Co., cline@

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.,
Trieu Chieu, IBM T.J Watson Research Center, IBM Corp.,

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,
Stephen Wong, Rice University,
Dung Nguyen, Rice University,
Phil Ventura, University at Buffalo, SUNY,
Michael Wick, University of Wisconsin - Eau Claire,

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,
Mary Lynn Manns, University of North Carolina at Asheville,

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,
Thomas Flor, DaimlerChrysler,
Walter Niess, DaimlerChrysler,
Gabriel Vögler, DaimlerChrysler,

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,
Iain Darroch, University of Glasgow,

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,
Edson Sussumu, University of São Paulo, Brazil,
Ariane Lima, University of São Paulo, Brazil,
Marcelo Brito, University of São Paulo, Brazil,
Jorge Del Teglia, University of São Paulo, Brazil,

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),
Matti Rossi, Helsinki School of Economics,
Juha-Pekka Tolvanen, MetaCase Consulting,

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,

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,
John Murphy, Performance Engineering Laboratory,

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

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,
Mohamed Fayad, Professor of Computer Engineering, College of Engineering, San José State University,

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,

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,
Doris Carver, Louisiana State University,
Robert France, Colorado State University,

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,
Wade Holst, The University of Western Ontario,

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,
Thomas Cleenewerck, Vrije Universiteit Brussel,
Wolfgang De Meuter, Vrije Universiteit Brussel,

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.

Student Research Poster Presentations at the Welcome Reception

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

Analyzing the Use of Interfaces in Large OO Projects

Philip Mayer, University of Hannover,

Using partial interfaces, i.e. interfaces that cover only a subset of the total set of published methods of a class, has several advantages, but research shows they are only sparsely used. Therefore, we have created a metrics suite and tool support to assist the developer in using partial interfaces.

Development of a high level view of Java applications

Eric Bodden, University of Kent, Canterbury, UK,

This work is about the development of an abstract view for Java programs, supporting refactoring and debugging for rather large applications. The implementation is based on static method call graph analysis on bytecode incorporating third party packages like SOOT, JavaCC and OpenJGraph. The work leads to a browseable visual graph.

Metamodel Based Model Transformation Language

Aditya Agrawal, ISIS, Vanderbilt University,

Domain Specific Model Driven Architectures (DSMDA) rely on the use of MDA for a specific domain. For each DSMDA, a transformer is needed to map domain models to implementation models. This paper describes a high-level specification language and execution framework to formally capture and realize the behavior of model transformers.

A Language Based Formalism For Domain Driven Development

Wei Zhao, Computer and Information Sciences, University of Alabama at Birmingham,

The evolution of programming languages has often been the driving force for the evolution of software development from the machine-centric to the application-centric. The 4th Generation Languages paradigm, languages defined directly by the composition of domain features, serves as the language-based formalism for the emerging Domain Driven Development paradigm.

A Framework for Using Component Redundancy for Self-Adapting and Self-Optimising Component-Based Enterprise Systems

Ada Diaconescu, Dublin City University,

We propose a framework that uses component redundancy for enabling self-adaptation, self-optimisation and self-healing capabilities in component-based enterprise software systems. Our framework is divided into three main logical tiers, operating in a feedback-loop manner: monitoring, evaluation and action.

Program Manipulation via Interactive Transformations

Marat Boshernitsan, University of California at Berkeley,

Changing program source code is complicated because many changes entail pervasive large-scale modifications. Developers use authoring and editing tools that are poorly suited to such maintenance tasks. We are creating a novel programming environment that lets the programmer describe source code manipulations in a more "natural" manner than is currently possible.

Issues on Building T++, a Tool for Web Application Development with C++

Antonio Terceiro, Federal University of Bahia,

As the demand for web applications grows, so does the demand for tools that support them. As a general rule, such tools extend general purpose programming languages, like Servlets/JSP does for JAVA, or define their own programming language, like PHP. But there is no established engine for web applications written with C++. This work presents technical challenges that were faced when developing T++, an engine that supports web application development with C++.

A Self-Optimizing Application Server Design for Enterprise Java Beans Applications

Mircea Trofin, Dublin City University,

We propose a self-optimizing application server design for EJB component technology. Optimizations are driven by the discovery of inter-component communication patterns and the application of corresponding container refactorings. Our solution attempts to address the impact the application server has on system performance.

Model Consistency in the Object Oriented Software Development Process

Gabriela Pérez, LIFIA,

Model Refinement is a relationship that relates two elements representing the same concept at different levels of abstraction. In UML, Refinement is described in an informal way. To avoid wrong model interpretations, we study a formalization of the refinement relation. This work provides an enhancement to the UML metamodel specification.

OOPSLA 2003 Welcome Reception

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

All full (and Tuesday one-day) conference registrants, along with the Tutorial-only registrants, are invited to attend the Welcome Reception. OOPSLA attendees are encouraged to view the OOPSLA 2003 Poster Session during the Welcome Reception. The Poster Session at the Welcome Reception is an informal and highly interactive environment that gives OOPSLA attendees the opportunity to engage with one another in discussions about relevant, ongoing work and critical issues in key areas. The session also gives conference attendees the chance to learn about work in areas with which they want to become familiar and about preliminary research results.

Newcomers Orientation

Monday, 27 October – 19:30-20:00

A special session, immediately following the OOPSLA 2003 Welcome Reception, targeted at first-time OOPSLA attendees, to help you maximize your OOPSLA experience. One thing that makes OOPSLA special is that everyone who participates can learn as long as everyone operates that way— OOPSLA is not a one-way (you listen, they speak) street. If you have never been to an OOPSLA before, this is a unique opportunity to meet other first-time OOPSLA participants early in the conference and begin what will become an outstanding way for you to stay on top of the trends in OO technology.