Home · Schedule · Tracks · Recommendations · Registration

Methods & Processes

Sunday, 26 October

8:30-17:00 Full day

Tutorial 15 Judging Use Case Quality: Patterns for Writing Effective Use Cases
Workshop 2: Are Agile Methodologies Really Different?
Workshop 6: Second International Workshop on Agent-oriented methodologies
Workshop 7: Process Engineering for Object-Oriented and Component-Based Development
Workshop 9: The 3rd OOPSLA Workshop on Domain-Specific Modeling
Workshop 11: Patterns for Retrospectives
Workshop 12: Second "Killer Examples" for Design Patterns and ObjectsFirst Workshop
Workshop 23: Open-Source in an Industrial Context

8:30-12:00 Morning

Tutorial 3: Domain Analysis for Product-Line Architectures
Tutorial 5: Evolutionary Design
Workshop 17: Extreme Programming Practices in the First CS Courses

13:30-17:00 Afternoon

Tutorial 11 Performance Solutions: Solving Performance Problems Quickly and Effectively
Tutorial 12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype
Tutorial 13: Large-Scale Agile Software Development

Monday, 27 October

8:30-17:00 Full day

Tutorial 34: Developing Java Applications for Small Devices Using Eclipse
Tutorial 35: Essential Object-Oriented Analysis and Design
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 13 Beyond Green-Field Software Development: Strategies for Reengineering and Evolution
Workshop 18 Bridging the Gap: Examining Approaches that Connect Business Requirements to Enabling Technology Solutions
Workshop 22: Web Services and Service-Oriented Architecture Best Practices and Patterns

8:30-12:00 Morning

Tutorial 25: Agile Requirements Specification

13:30-17:00 Afternoon

Tutorial 31: Technical Leadership In Practice
Tutorial 32: Domain-Driven Design
Tutorial 33: From Component Reuse to Asset-Based Software Engineering

Tuesday, 28 October

13:30-17:00 Afternoon

Tutorial 21: Feature Oriented Programming and Product-Lines
Tutorial 38: Project Retrospectives in Agile Development
Tutorial 40: An Overview of UML 2.0

Wednesday, 29 October

13:30-17:00 Afternoon

Tutorial 44: Notes on the Forgotten Art of Software Architecture
Tutorial 45: Test-Driven Development with "fit", the Framework for Integrated Test
Tutorial 46 Object-Oriented Reengineering: Patterns & Techniques
Tutorial 52 Agile Database Techniques: Data Doesn't Have To Be A Four Letter Word Anymore

Thursday, 30 October

8:30-12:00 Morning

Tutorial 53 Legacy: The Other Kind of Inheritance
Tutorial 54: Running Agile Software Development Projects with RUP

15 Judging Use Case Quality: Patterns for Writing Effective Use Cases

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

Steve Adolph, WSA Consulting Inc., steve@wsaconsulting.com
Paul Bramble, Emperative, Inc., Pbram47077@aol.com

Use cases are a wonderfully simple concept: describe a system's functional requirements by telling stories about how its actors use it. However, developers are discovering that writing effective use cases is more difficult than they had anticipated. Use case writers frequently must deal with difficult questions, such as:

  • What should be the scope of a use case?
  • How long should a use case be?
  • What level of detail should a use case express?
  • What expertise is required in the use case writing team?
  • How do we provide different levels of detail for different people?
  • Where do I put the requirements for the external interfaces and stored data?
  • Why am I doing this in the first place?

Usually, the answers to these questions is prefixed with an unsatisfying "Well, it depends."

An understanding of basic principles is not enough. Developers need a source of objective criteria to judge use case quality and effectiveness. This tutorial helps fill a critical information gap by presenting a pattern language that provides simple, elegant, and proven solutions to common problems in use case development. It captures the knowledge and experience of successful use case developers in a way that it can be easily used by others, and serves as the basis of a vocabulary describing the properties of quality use cases. As such, these patterns facilitate the development of original use cases and provide a diagnostic tool for evaluating existing ones.

Attendee background

Prerequisites: Attendees must have experience in using or preparing use cases, and be familiar with basic use case concepts.

Format

Interactive lectures and hands-on exercises, plus question-and-answer session

Presenters

Steve Adolph is a senior consultant with WSA Consulting Inc., where he specializes in software process improvement. He has twenty years of industrial experience developing software and managing software development projects in the telecommunications, railway signaling, and graphic arts industry. An exciting and enthusiastic speaker, Mr. Adolph has spoken at numerous seminars and workshops on software project management, object-oriented analysis and design, and patterns. He is co-author of the book "Patterns for Writing Effective Use Cases."

Paul Bramble is a Senior Software Engineer with Emperative, Inc., specializing in object-oriented software development and distributed systems. He has been developing software in the telecommunication, avionics, and computer manufacturing industries for over 20 years. Paul has been using and researching use cases since 1994, and co-authored the book "Patterns for Writing Effective Use Cases." He has given several presentations on use cases at the industrial and university levels, including at OOPSLA events.

2 Are Agile Methodologies Really Different?

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

Jens Coldewey, Coldewey Consulting, jens_coldewey@acm.org
Pete McBreen, McBreen Consulting, pete@mcbreen.ab.ca
Mary Poppendieck, Poppendieck LLC, mary@poppendieck.com

With Adaptive Software Development, Crystal, Extreme Programming, Feature Driven Development, Lean Development, and Scrum the ecosystem of agile methods seems to stabilize. Though they all use different metaphors and approaches to software development, their hands-on results are so similar that readers may ask themselves, whether they are really different methodologies. Practitioners have had the best results combining elements of different agile methodologies — a possibility that defines a common species in biology.

This sequel to last year's OOPSLA workshop "Commonalities of Agile Methodologies" explores this question in depth in a highly interactive setting. It may work on questions like "What is different anyhow and why?", "What forces drive particular solutions?", or "How does a solution deal with limitations?".

http://www.coldewey.com/publikationen/conferences/oopsla2003/differences.html

6 Second International Workshop on Agent-oriented methodologies

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

Paolo Bresciani, ITC-Irst (Italy), brescian@itc.it
John Debenham, University of Technology, Sydney (Australia), debenham@it.uts.edu.au
Paolo Giorgini, University of Trento (Italy), pgiorgio@science.unitn.it
Ian Gorton, Pacific Northwest National Laboratory (USA), ian.gorton@pnl.gov

Following the success of object technology, the next advance is likely to be the introduction, adoption and widespread use of agent technology for business applications. Agents, building as they do in part on objects, require careful design. Appropriate methodologies for constructing agent-oriented systems may rely to some degree on OO methodologies, but their distinct autonomy of an agent means that these agent-oriented processes cannot be as deterministic as they have been in object-oriented developments. Support for emergent processes is required as well as further modifications to existing OO processes.

The overall goal of the workshop is to consolidate a research agenda for the next five years that will enable agent-oriented methodologies to become of "commercial strength" and to be widely adopted by industry.

http://www.open.org.au/Conferences/oopsla2003/AO.html

7 Process Engineering for Object-Oriented and Component-Based Development

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

Don Firesmith, SEI (USA), opfwebsite@hotmail.com
Cesar Gonzalez-Perez, University of Technology, Sydney (Australia), cesargon@it.uts.edu.au
Brian Henderson-Sellers, University of Technology, Sydney (Australia), brian@it.uts.edu.au
Pavel Hruby, Microsoft Business Solutions (Denmark), phruby@acm.org
Dilip Patel, South Bank University (UK), dilip@vax.sbu.ac.uk
Dan Rawsthorne, Net Objectives (USA), DrDan@NetObjectives.com
Bernhard Rumpe, Munich University of Technology (Germany), rumpe@in.tum.de
Magdy Serour, University of Technology, Sydney (Australia), magdy@serour.com
Hadar Ziv, eBuilt Inc., (USA), ziv@ics.uci.edu

During the last decade, Object-Oriented/Component Based Development has gained a wide acceptance from both academics and practitioners as the current optimal technology for software development. This has led to the creation of a plethora of OO methodologies and, more recently, OO processes. Many attempt to provide a "one size fits all" process.

An alternative that we explore in this workshop is to construct and/or tailor a process specifically for the organization by use of the technique of process engineering. While the creation of process components is reasonably mature, the guidelines to help organizations construct their own process from these process components are little understood. The workshop aims to create concrete advice to organizations on process construction and process tailoring. This will require interchange of ideas and experiences between researchers and practitioners.

http://www.open.org.au/Conferences/oopsla2003/PE.html

9 The 3rd OOPSLA Workshop on Domain-Specific Modeling

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

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

Today, domain-specific visual languages provide a viable solution to raise the level of abstraction beyond coding. Industrial experience has shown productivity improvements of 5-10 times. We believe that it is time to start talking about Domain-Specific Modeling as the new paradigm for developing applications and product families for a given domain/platform.

In domain-specific modeling the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with generators and components DSM can automate a large portion of software production.

Workshop topics:

Industry/academic experience reports

  • Approaches to identify constructs for DSMs
  • Novel approaches for code generation from domain-specific models
  • Issues of support/maintenance for systems built with DSMs
  • Evolution of languages in accordance with domain
  • Metamodeling frameworks and languages
  • Tools for supporting DSMs

http://www.cis.uab.edu/info/OOPSLA-DSM03/

11 Patterns for Retrospectives

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

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

The theme of this workshop is patterns for retrospectives. Retrospectives are important, not only for object technology, but for any human activity: to provide time for reflection, to improve on performance, and to increase our understanding of the task at hand. The Principles Behind the Agile Manifesto state that, "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." There have been articles and an excellent book (Norm Kerth's Project Retrospectives) written on this topic but as is the case for many domains, experts know much that novices do not. We believe that documenting expertise in patterns is an excellent way to share knowledge.

The goal of this workshop is to begin documenting patterns for retrospectives and looking for a pattern language structure.

http://www.unca.edu/~manns/retropatterns.html

12 Second "Killer Examples" for Design Patterns and ObjectsFirst Workshop

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

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

According to the Jargon File a "killer app" is an "application that actually makes a sustaining market for a promising but under-utilized technology." A "killer example" provides clear and compelling motivation for a design pattern or design principles. An example is "killer" if it compels someone to spontaneously "buy-in" to that design pattern or technique.

"Killer examples" are important pedagogically because they get students on-board and excited about design in general and design patterns in particular. They are useful to convince peers or employees, not familiar with object-oriented design, that design patterns are central to good object-oriented practices and that they are not an esoteric topic that is best left to expert.

The workshop's goal is to bring together educators and developers who have "killer examples" to share. Pre-workshop activities encourage interaction and refinement of examples prior to the workshop.

http://www.cse.buffalo.edu/~alphonce/KillerExamples

23 Open-Source in an Industrial Context

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

Manfred Broy, Technische Universität München, broy@in.tum.de
Thomas Wieland, University of Applied Sciences Coburg, thomas@drwieland.de
Marc Sihling, 4Soft GmbH, sihling@in.tum.de

Open-Source software development moved into the focus of common interest a couple of years ago and by now, software engineers learned a lot about the dos and don'ts which often prove beneficial even for industrial software development projects. However, there are many more ways in which industrial software development can benefit from open-source communities — and vice versa.

In this workshop, we will elaborate on different aspects that help to establish this mutual benefit.

http://osic.in.tum.de/

3 Domain Analysis for Product-Line Architectures

Sunday, 26 October – 8:30-12:00 Morning

Neil Harrison, Avaya Labs Research, nbharrison@avaya.com
Frank Buschmann, Siemens AG, Corporate Technology, Frank.Buschmann@siemens.com

Product-line architectures promise better productivity and less maintenance costs for families of related software systems. A strong product-line architecture is one of the keys to a successful deployment of both product lines and any system destined to go through multiple releases. However, specifying high-quality product-line architectures is a surprisingly difficult task.

Commonality and variability analysis is a powerful domain analysis tool for the specification of product lines. It can help designers produce systems that are robust in the face of change, and that can be easily customized. Additionally, it feeds naturally into OO design. This combination provides a proactive, systematic approach to accomodating changes in software.

This tutorial introduces commonality and variability analysis in a real-world setting. Topics include: underlying principles, methodology, and synthesis with OO design. By the end of the tutorial, you will understand how to use commonality and variability analysis in your OO projects to specify a stable, yet flexible, software architecture.

Attendee background

This tutorial is aimed at architects and designers of systems that have many variations, such as product families and systems with multiple releases.

Prerequisites: Attendees should have solid background in OO principles, and some OO design experience. Experience in specification or analysis is helpful but not required.

Format

Lecture with exercises

Presenters

Neil Harrison is a researcher at Avaya Labs, where he consults with software projects in architecture, process, organizations, estimation, and product line engineering. He has been involved in software patterns since 1994. He has organized pattern conferences and has taught many courses on patterns. He is a member of the Hillside Group board of directors. He has published patterns and chapters in pattern books, and was lead editor of Pattern Languages of Program Design, Volume 4.

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Software Architecture, and Patterns. Frank has been involved in many software development projects. He is leading Siemens' software architecture 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".

5 Evolutionary Design

Sunday, 26 October – 8:30-12:00 Morning

Joshua Kerievsky, Extreme Programmer and Coach, Industrial Logic, Inc., joshua@industriallogic.com
Russ Rufer, Extreme Programmer and Coach, Industrial Logic, Inc., russ@industriallogic.com

While Test-Driven Development and Refactoring are extremely useful software development practices, they are insufficient for evolving great designs. What's missing are the thinking and coding practices that real-world evolutionary designers use to evolve top-notch designs effectively. Such practices include critical learning that results from early end-to-end system development, significant time savings obtained by determining what doesn't need to be automated, eye-opening design simplicity achieved by automating failing acceptance tests before writing code, important design progress that results, paradoxically, from undoing previous design work and more.

This tutorial takes the mystery out of Evolutionary Design by naming and explaining what its thinking and coding practices are and how to implement them. You'll be challenged to solve Evolutionary Design exercises and you'll experience how a game of blackjack evolves from a first failing UI test to a functioning version of the game. Along the way you'll learn how not to evolve blackjack, you'll study micro-snapshots of the evolution-in-progress and you'll understand what the evolution of a game teaches us about Evolutionary Design on real-world projects.

Attendee background

Prerequisites: Participants should be able to read Java™ code to get the most out of the session. No background is required in Agile Development, Refactoring, or Test-Driven Design.

Format

Interactive lecture and programming demonstration

Presenters

Joshua Kerievsky has been programming professionally since 1987, and is the founder of Industrial Logic (http://industriallogic.com), a company specializing in Extreme Programming (XP). Since 1999, Joshua has been coaching and programming on small, large and distributed XP projects and teaching XP to people throughout the world. He is the author of numerous XP and patterns-based articles, simulations and games, including the forthcoming book, Refactoring to Patterns (http://industriallogic.com/xp/refactoring/).

Russ Rufer has been building software systems for 15 years. His wide-ranging experience includes desktop applications, embedded firmware, telecommunications, networking, satellite simulation, and productivity tools. Russ leads weekly meetings of the Silicon Valley Patterns Group, which he founded in 1998 (http://pentad.com/SiliconValleyPatterns.html) and regularly organizes pre-publication review teams to provide feedback on new literature from the software patterns and agile development communities. Russ has worked with Industrial Logic for several years. He divides his time between pure development, coaching and leading workshops on Extreme Programming, Testing, Refactoring and Patterns.

17 Extreme Programming Practices in the First CS Courses

Sunday, 26 October – 8:30-12:00 Morning

Joseph Bergin, Pace University, berginf@pace.edu
James Caristi, Valparaiso University, James.Caristi@valpo.edu
Daniel Steinberg, Dim Sum Thinking, Inc., DSteinberg@core.com

Most of the practices of Extreme Programming are beneficial to students in their computer science courses. But in order to teach students properly, pedagogical changes are needed as early as CS1. This workshop seeks participants who have significant ideas for changes that can be made in early computer science courses that involve integrating any of the practices of Extreme Programming or other agile methodologies.

Would-be participants should send in a short position paper outlining one or two ideas they have. During the workshop, participants will critically discuss the ideas that have been suggested and explore any new ones that arise. Participants will agree to allow their ideas to be shared via a web page to be posted in various CS educational resources repositories.

http://csis.pace.edu/~bergin/XPWorkshop

11 Performance Solutions: Solving Performance Problems Quickly and Effectively

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

Connie U. Smith, Performance Engineering Services, cusmith@perfeng.com
Lloyd G. Williams, Software Engineering Research, boulderlgw@aol.com

If you've got performance problems, you need help to get out of trouble now. This tutorial is designed to provide you with basic knowledge that you can immediately apply to improve the performance of your software. It presents a practical approach to identifying sources of performance problems. Whether you are involved in new development or upgrading a legacy system, this tutorial will help you quickly and effectively achieve your goals for responsiveness and scalability without sacrificing other quality objectives, such as reliability, modifiability, or security. We'll also introduce techniques that help you determine whether a legacy system is worth fixing or beyond repair.

Attendee background

Prerequisites: Attendees should be familiar with object-oriented development. No background or experience in software performance engineering is required.

Format

Lecture

Presenters

Dr. Connie U. Smith is Principal Consultant of the Performance Engineering Services Division of L&S Computer Technology, Inc. She specializes in applying performance prediction techniques to software, developing SPE tools, and teaching SPE seminars. She is the author of the original SPE book, "Performance Engineering of Software Systems." She is known for her seminal work in defining the field of SPE and integrating SPE into the development of new software systems.

Dr. Lloyd G. Williams, principal consultant at Software Engineering Research, is internationally recognized for his work in the development and evaluation of software architectures to meet quality objectives including performance, reliability, modifiability, and reusability.

Together, Drs. Smith and Williams have over 50 years of experience in software development. They have worked together for approximately 15 years to help clients design and implement software that meets performance objectives. They have published numerous technical papers and articles, and coauthored the book, "Performance Solutions: A Practical Guide to Creating Responsive, Scalable Software," published in Addison-Wesley's Object Technology Series in 2002.

12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype

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

Ali Arsanjani, IBM Corporation and Maharishi University of Management, arsanjan@us.ibm.com
Bruce Anderson, IBM Corporation, bruce_anderson@uk.ibm.com

This intense and unique tutorial provides an introduction and step-by-step walkthrough of the state of the art of Web services (WS) and Service-oriented Architectures (SOA).

The tutorial presents overviews of key web services standards (including WS-I, WSIF, WSIL, SOAP, WSDL, UDDI) considerations for their use, and some tools and technologies (including Apache Axis and related projects) that can be employed to implement them. Next, it presents an architectural blueprint for web services architecture that can server as a basis for most projects. With these standards, considerations, tools and blueprint in hand, we present a set of concrete process steps that lead to the realization of an SOA.

The tutorial will then present a set of patterns for the design and implementation of web services based architectures including Business Service, Service Gateway, SOAP Document, and SOAP Method. We also discuss methods for assessment that can be used as checklists by architects who wish to evaluate web services architectures.

Finally, to tie these togather, we will present two case studies, from the financial services and retail purchasing domains.

Attendee background

Prerequisites: Basic knowledge of object-oriented development, and some knowledge of software architecture, design and implementation, are required.

Format

Lecture and hands-on exercises

Presenters

Ali Arsanjani has over 19 years of industrial experience. He is a Senior Consulting I/T Architect for IBM's National E-business Application Development Center of Competency, where he leads the Component-based Development and Integration Competency area. He has been architecting n-tier e-business systems based on object, component, and service-oriented technologies for IBM's larger clients. His areas of experience and research include component-based development, service-oriented architectures, business rules modeling and implementation, creation and evolution of reusable assets, extending methods for CBD, building business frameworks and components and incorporating patterns and pattern languages to build resilient and stable software architectures. He has been actively speaking and publishing in these areas for a variety of industrial and academic audiences.

Bruce Anderson is a Senior Consultant in IBM's Component Technology Services. He specialises in working with customer organisations to create powerful component- and object-based solutions, and in helping individuals to develop their knowledge and understanding. Typically, Mr. Anderson leads planning and definition work, and mentoring programme leaders, project managers or architects into their roles.

13 Large-Scale Agile Software Development

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

Ron Crocker, Motorola, ron@roncrocker.com

All of this XP and Agile Methods hype is wonderful, but how can people who work on large-scale software projects (i.e., projects with more than 100 people and longer than 1 year duration) take advantage of the benefits in quality, efficiency, and time promised by the hype?

That question is answered in this tutorial. We will go through an approach--one that has worked well in practice--that enables teams to collaborate in an agile way on large projects. This tutorial will cover the following topics:

  • Why large projects are indeed different
  • Why existing agile methods (XP, Scrum, ...) are insufficient to deal with large projects
  • A set of agile practices enabling agile multi-team collaboration
  • Experiences with the practices
  • How you can do something differently when you get back home

At the end of the session, you will leave the room either shaking your head saying, "I wish I could do that," or you will have definite plans to try these practices when you get back to work.

The material in this tutorial comes principally from the presenter's forthcoming book, "Large-Scale Agile Software Development," which may be available in time for OOPSLA.

Attendee background

This tutorial is geared towards practitioners, software or process engineers in development leadership roles, or someone with influence on such people.

Prerequisites: Experience developing large systems, and exposure to the attendant difficulties of doing so, is required. Knowledge of object technologies is not essential, but it is helpful.

Format

Lecture

Presenter

Ron Crocker is a Fellow of the Technical Staff in the Network and Advanced Technologies group of Motorola's Global Telecom Solutions Sector, where he has pioneered the application of advanced software technologies and processes in the development of next-generation cellular telecommunications systems. He is the author of the forthcoming Addison-Wesley book "Large-Scale Agile Software Development."

34 Developing Java Applications for Small Devices Using Eclipse

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

Chris Laffra, IBM Canada, Chris_Laffra@ca.ibm.com
Michael van Meekeren, IBM Canada, Michael_van_Meekeren@ca.ibm.com

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.

Format

Lecture and demonstrations

Presenters

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, jill.aden@eds.com
Joseph Brennan, EDS, joseph.brennan@eds.com

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.

Format

Lecture

Presenters

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.

3 Generative techniques in the context of MDA

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

Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com
Ghica van Emde Boas, Bronstee.com Software & Services, emdeboas@bronstee.com
Aditya Agrawal, Vanderbilt University, Aditya.Agrawal@vanderbilt.edu
Ed Willink, Thales Research, Ed.Willink@thalesgroup.com
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.

http://www.softmetaware.com/oopsla2003/mda-workshop.html

4 Agile Contracts

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

Mary Poppendieck, Poppendieck.LLC, mary@poppendieck.com
Ken Schwaber, Advanced Development Methods, Inc., ken.schwaber@verizon.net
Tom Poppendieck, Poppendieck.LLC, tom@poppendieck.com

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.

http://www.leantoolkit.com/agilecontractsworkshop.htm

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, haimk@acm.org
Kenneth Baclawski, Northeastern University, ken@baclawski.com

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.

http://www.ccs.neu.edu/home/kenb/oopsla2003

8 Multiple Viewpoints for System Modeling

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

Fred Cummins, EDS, fred.cummins@eds.com
Cory Casanave, Data Access Technologies, cory-c@enterprise-component.com
William Frank, Domain Architects, wff@domainarchitects.com
Stan Hendryx, Hendryx Associates, stan@HendryxAssoc.com
Steven Mellor, Project Technology, steve@projtech.com
Joaquin Miller, Domain architects, joaquin@acm.org

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.

http://www.enterprise-component.com/oopsla2003/

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, mancl@lucent.com
William Opdyke, North Central College, opdyke@acm.org
Steven Fraser, Consultant, sdfraser@acm.org
Willem-Jan van den Heuvel, Infolab Tilburg University, W.J.A.M.vdnHeuvel@uvt.nl

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

http://csc.noctrl.edu/f/opdyke/OOPSLA2003

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., ralph@topquadrant.com
Dave Parrish, Management Science Associates, Inc., dparrish@msa.com
Christine Brautigam, Direct Dynamics, Inc., christine@directdynamics.biz
Dr. Robert F. Coyne, TopQuadrant, Inc., robert@topquadrant.com

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.

http://www.topquadrant.com/workshops/oopsla2003.htm

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

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

Ali Arsanjani, IBM Corporation, arsanjan@us.ibm.com
Kerrie Holley, IBM, holley@us.ibm.com

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.

http://www.arsanjani.com/oopsla2003/webservices.htm

25 Agile Requirements Specification

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

Jennitta Andrea, ClearStream Consulting Inc., jennitta@clrstream.com
Gerard Meszaros, ClearStream Consulting Inc., gerard@clrstream.com

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.

Format

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.

Presenters

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.

31 Technical Leadership In Practice

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

Andrew Schneider, BJSS (www.bjss.co.uk), as@bjss.co.uk

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.

Format

Lecture, group discussion, and copious real world examples

Presenter

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., eric@domainlanguage.com
Ralph Johnson, University of Illinois, johnson@cs.uiuc.edu

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.

Format

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

Presenters

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, martin@griss.com

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.

Format

Lecture and interactive discussion

Presenter

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.

21 Feature Oriented Programming and Product-Lines

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

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

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

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

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

Attendee background

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

Format

Lecture

Presenter

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

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

38 Project Retrospectives in Agile Development

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

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

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

Attendee background

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

Format

Introductory lecture and simulated retrospective

Presenters

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

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

40 An Overview of UML 2.0

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

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

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

Attendee background

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

Format

Lecture

Presenter

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

44 Notes on the Forgotten Art of Software Architecture

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

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

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

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

Attendee background

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

Format

Lecture

Presenter

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

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

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

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

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

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

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

Attendee background

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

Format

Lecture, demonstration, and optional exercises

Presenter

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

46 Object-Oriented Reengineering: Patterns & Techniques

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

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

Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Software engineers are now confronted with millions of lines of code, developed using object-oriented design methods and languages of the late 80s and early 90s. These systems exhibit a range of problems, effectively preventing them from satisfying the evolving requirements imposed by their users.

This tutorial will share our knowledge concerning the reengineering of object-oriented legacy systems. We will draw upon our experiences with the FAMOOS project to show you techniques and tools we have used on real industrial OO systems to detect and repair problems. In particular, we will discuss approaches such as reverse engineering, design extraction, metrics, refactoring and program visualisation.

Attendee background

Prerequisites: Participants should have practical programming experience in at least one OO language (Smalltalk, C++, Java, Eiffel, etc.). Familiarity with UML is useful, though not required.

Format

Lecture

Presenters

Serge Demeyer is a professor in the Department of Mathematics and Computer Science at the University of Antwerp in Belgium. He leads a research group investigating software reengineering (LORE - Lab On REengineering). His main research interest concerns software engineering (more precisely, reengineering in an object-oriented context), but for historical reasons, he maintains a heavy interest in hypermedia systems as well. He is an active member of the corresponding international research communities, serving on various conference organizing and program committees.

Stéphane Ducasse is an assistant professor in the Software Composition Group at the University of Berne. He served as technical leader of the FAMOOS Esprit project, a project whose goal was to propose a set of reengineering techniques and tools to support the development of object-oriented frameworks. He is an expert in object-oriented programming, design patterns, framework development, reflective programming and component technology. He is one of the main designers of the MOOSE reengineering environment that is the basis for CodeCrawler, a program understanding tool. He is the main organizer of the annual European Smalltalk Advanced Seminars.

Oscar Nierstrasz is a Professor of Computer Science at the University of Berne, where he leads the Software Composition Group. He is the author of numerous publications on object-oriented and component-based technology. He has been active in the object-oriented research community for many years, serving on the programme committees of the ECOOP, OOPSLA and many other conferences.

52 Agile Database Techniques: Data Doesn't Have To Be A Four Letter Word Anymore

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

Scott Ambler, Ronin International, Inc., scott.ambler@ronin-intl.com

Many modern object-oriented applications must manipulate data stored in relational databases (RDBs). There is a well-known technical impedance mismatch between the object-oriented and relational models that must be overcome to permit such integration. Equally important but less publicized, there is also a cultural impedance mismatch between OO developers and relational database professionals. If modern software development is to succeed, we need to find ways to overcome both mismatches.

This tutorial addresses both the technical and cultural impedance mismatches between object and relational technologies and practitioners. To address the technical mismatch, we discuss techniques that data professionals can follow to support agile software development efforts, including database refactoring, evolutionary data modeling following the practices of Agile Modeling using the UML, mapping techniques, object/relational database implementation strategies, and Test-Driven Development (TDD). To address the cultural mismatch, we describe the skills and knowledge that agile software developers need to gain over time to be effective with respect to data-oriented development activities.

Attendee background

Prerequisites: Attendees must have an understanding of the fundamentals of agile software development.

Format

Lecture

Presenter

Scott Ambler is a noted expert in data management and agile methods. He is author of several books, including "The Object Primer 3rd Ed.", "Agile Modeling," and "Agile Database Techniques."

53 Legacy: The Other Kind of Inheritance

Thursday, 30 October – 8:30-12:00 Morning

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

There it is. All that code. And you weren't responsible for its development. That fact alone is normally enough for most individuals to berate the code as flawed and unmanageable. But once past the reflex response, there may actually be a problem. Software that you didn't develop, and especially code that has evolved over a long period of time, is never a green field. The code itself is just the tip of an iceberg that includes history, politics, anthropology, and economics, but rarely any post-enlightenment reasoning.

How do you get your head around this stuff? How do you work with it? How do you move it forward without being so busy breaking eggs that you never have time to make the omelet? This tutorial takes a stroll through some of the issues plus some of the tips and tricks that might help out. There is no big vision and no technology sell. Indeed, one of the most significant pitfalls to be aware of is falling into the fashion trap, adopting the latest and greatest technology fad and declaring it to be the one true way forward. A succession of fashion parades is often responsible for putting some of the 'gac' into legacy.

Attendee background

This tutorial is targeted at programmers, managers, and other interested technical parties who find themselves working in or in contact with legacy code.

Format

Lecture

Presenter

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

54 Running Agile Software Development Projects with RUP

Thursday, 30 October – 8:30-12:00 Morning

Michael Hirsch, Zühlke Engineering AG, Hirsch.Michael@acm.org

The Rational Unified Process (RUP) is a comprehensive process covering almost all aspects of software development projects. Due to its great level of detail, RUP has--quite wrongly--the reputation of being too heavyweight for agile development projects. In this tutorial, you will learn how to configure RUP for agile development. Topics covered include what artifacts to use and not to use, best practices for planning and monitoring projects, best practices for handling requirements, analysis and design, and how to introduce agile RUP into a project or in an organization. About 25% of the time of the tutorial is devoted to a demonstration of a real world project which has been successfully completed with an agile version of RUP.

Attendee background

This tutorial is aimed at project managers, software architects, software process specialists and software developers who are evaluating RUP for agile development or who are involved in a project where RUP is already used and want to make it more agile. Knowledge of RUP basics is helpful but not required.

Format

Lecture and demonstration

Presenter

Michael Hirsch has 20 years of experience in the software industry in various roles, including project manager, software architect and software developer. During the last 10 years, he has been with Zühlke Engineering AG, a software contractor and software consultancy in Switzerland. He has been using RUP since 1998, when he led a team that introduced RUP at Zühlke Engineering and adapted it to the company's needs. Since then Zühlke Engineering has successfully completed about 20 projects with an agile version of RUP. Today, Michael splits his time between managing software development projects, coaching and mentoring project teams, and teaching classes on software processes and object oriented analysis and design. He is a member of ACM and IEEE, and has a degree in electrical engineering from HTL Bregenz in Austria and a degree in software engineering from HTL Berne in Switzerland.