Home · Schedule · Tracks · Recommendations · Registration

Tutorials

Chair: Peri Tarr, IBM Thomas J. Watson Research Center, tutorials@oopsla.acm.org

OOPSLA's renowned, world-class tutorials program offers you the knowledge you need to be most effective in today's demanding research and industrial climate. Nowhere else can you find such a broad selection of OO-related topics, taught by some of the most influential and innovative people in the field.

Whatever your experience level, background, or role, and whether you need to stay current or acquire new skills, OOPSLA tutorials are your one-stop information source for everything OO: from introductions to object-oriented development, to the latest standards, languages, technologies, and methodologies, to state-of-the-art and on-the-horizon topics.

If you aren't sure which tutorial(s) are right for you, contact the tutorials chair at tutorials@oopsla.acm.org.

Sunday, 26 October

8:30-17:00 Full day

15 Judging Use Case Quality: Patterns for Writing Effective Use Cases
16 Concepts of Object-Oriented Programming
17 Programmer's Dozen: Thirteen Recommendations for Refactoring, Repairing, and Regaining Control of Your Code
18 An Introduction to Software Product Lines
19 Automated Software Testing: Hands On and Interactive!

8:30-12:00 Morning

1 Scrum and Agile Process 101
2 Introduction to Concurrent Programming in Java
3 Domain Analysis for Product-Line Architectures
4 Introduction to Aspect-Oriented Programming with AspectJ
5 Evolutionary Design
6 Eclipse Extensions—Making the Connections
7 Programming Internet-Scale Distributed Applications in the 21st Century: BPEL and Beyond

13:30-17:00 Afternoon

8 Patterns @ Work
9 Java Concurrency Utilities: Tools for Managing Multi-threading
10 Advanced Aspect-Oriented Programming with AspectJ
11 Performance Solutions: Solving Performance Problems Quickly and Effectively
12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype
13 Large-Scale Agile Software Development
14 An Introduction to the Common Language Infrastructure (CLI)

Monday, 27 October

8:30-17:00 Full day

34 Developing Java Applications for Small Devices Using Eclipse
35 Essential Object-Oriented Analysis and Design
36 Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects

8:30-12:00 Morning

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

13:30-17:00 Afternoon

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

Tuesday, 28 October

13:30-17:00 Afternoon

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

Wednesday, 29 October

13:30-17:00 Afternoon

44 Notes on the Forgotten Art of Software Architecture
45 Test-Driven Development with "fit", the Framework for Integrated Test
46 Object-Oriented Reengineering: Patterns & Techniques
47 Enterprise Application Integration with J2EE and .NET
48 Guided Inspection of UML Models
49 Extending Enterprise Systems with Mobile/Wireless Applications
50 Understanding Circa-2003 XML Technologies
51 Designing Reliable Collaborations
52 Agile Database Techniques: Data Doesn't Have To Be A Four Letter Word Anymore

Thursday, 30 October

8:30-12:00 Morning

53 Legacy: The Other Kind of Inheritance
54 Running Agile Software Development Projects with RUP
55 J2EE in Practice: Architectural Variations in the Context of Enterprise Systems
56 Model-Driven Architecture
57 Test-Driven Development Workout: Building Java Muscle
58 Object-Oriented Modelling with UML

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.

16 Concepts of Object-Oriented Programming

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

Raimund Ege, Florida International University, ege@cs.fiu.edu

This tutorial defines and teaches the basic object-oriented concepts, illustrates their advantages, and introduces the components and features of object-oriented programming languages and development environments. The tutorial enables an attendee to make an informed decision about what language/environment will best serve his/her software development needs.

The first part of the tutorial discusses in detail all object-oriented concepts and uses UML and Java to illustrate them. The focus will be on a precise, non-confusing definition of the core concepts and terminology. Basic object-oriented concepts, such as object, instance, class, interface, attribute, service, message passing, hierarchy, inheritance, polymorphism, late binding, memory management, access specification and packaging, will be presented.

The second part of the tutorial compares the major object-oriented programming languages: C++, Java, C#, and others. The comparison is done with a double focus: (1) how does the language support and enforce the concepts, and (2) how does the language help software development? A small case study program, solved in all the languages, will be presented to answer these questions. Whether and how each language supports advanced concepts, like multiple and repeated inheritance, genericity, interfaces, is discussed in detail.

Attendee background

This tutorial is targeted towards software professionals who are interested in learning the fundamental concepts and advantages of object-oriented programming and how to apply them in a modern software development environment. No previous knowledge of object-oriented concepts is assumed. The attendees should have a fundamental background in computer science and/or computer programming.

Format

Lecture

Presenter

Raimund K. Ege is an Associate Professor of Computer Science at the Florida International University, Miami. He is author of several books on object oriented concepts, including a chapter on the Object-Oriented Language Paradigm in the upcoming "Computer Science and Engineering Handbook" edited by Allen B. Tucker (CRC Press, 2003). He is an active researcher in the area of object-oriented concepts, and their application to programming, user interfaces, databases, simulation and software engineering. He has presented numerous successful and highly rated tutorials at major conferences (OOPSLA, ECOOP, TOOLS).

17 Programmer's Dozen: Thirteen Recommendations for Refactoring, Repairing, and Regaining Control of Your Code

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

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

There is no shortage of technical wisdom on how to develop clear and robust code, so why is cryptic code and the corresponding look of puzzlement on a programmer's face such a common sight? Many companies and developers want to use state-of-the-art development practices, but seem swamped and bemused by how much state there really is to that art.

The tutorial offers a concrete, thirteen-point list of recommendations (zero through twelve) that can be applied immediately to reduce code size and complexity, acting as both guidelines for new code and indicators for refactoring. The short list has no ambition to be all that you needed to know about design but were afraid to ask, but it does offer an easily learned and easily practiced set of guidelines that offer the greatest immediate return on investment--the most bang for your buck or oomph for your euro.

Attendee background

This tutorial is targeted at people who write code for a living, typically using a curly-bracket language (C++, C#, Java, etc.) and are looking for that extra edge that allows them to keep their code live and clean.

Format

Lecture

Presenter

Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, object orientation, component-based development, 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.

18 An Introduction to Software Product Lines

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

Linda Northrop, Software Engineering Institute, lmn@sei.cmu.edu
Paul Clements, Software Engineering Institute, clements@sei.cmu.edu

Software product lines have emerged as a new and very important software development paradigm. A software product line is a set of software-intensive systems sharing a common, managed set of features, and that are developed in a disciplined fashion using a common set of core assets. Organizations developing their family of products as a software product line are experiencing order-of-magnitude improvements in cost, time to market, staff productivity, and quality of the deployed products. This tutorial covers the basic concepts of software product lines, the essential software engineering and management practices, and product line practice patterns that let an organization apply the practices in a way best suited to their individual needs. The concepts are illustrated with one or more detailed case studies of actual organizations' experiences with the software product line approach. The tutorial contents are based on the book "Software Product Lines: Practices and Patterns."

Attendee background

Prerequisites: Participants should have experience in designing and developing software-intensive systems and some familiarity with modern software engineering concepts and management practices.

Format

Lecture (65%) with discussion (20%) and short exercises (15%)

Presenters

Linda Northrop is currently director of the Product Line Systems Program at the Software Engineering Institute (SEI). She is co-author of the book, "Software Product Lines: Practices and Patterns." She received the 2001 Carnegie Science Center Award for Excellence in Information technology, was a keynote speaker at ICSE 2001 and AOSD 2002, OOPSLA Program Chair in 1999, OOPSLA Conference Chair in 2001, and the Conference Chair of the first and second international Software Product Line Conference (SPLC1 and SPLC2). She chaired the first Software Product Line Conference and is the current OOPSLA Steering Committee Chair.

Paul C. Clements is a Senior Member of the Technical Staff at Carnegie Mellon University's Software Engineering Institute. He is co-author of four books on architecture and product lines: "Software Product Lines: Practices and Patterns," "Software Architecture in Practice," "Evaluating Software Architectures: Methods and Case Studies," and "Documenting Software Architectures: Views and Beyond."

19 Automated Software Testing: Hands On and Interactive!

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

Gerard Meszaros, ClearStream Consulting, gerard.meszaros@acm.org
Ralph Bohnet, ClearStream Consulting, ralph@clrstream.com

This tutorial takes the "extreme" out of Extreme Programming. It brings the expertise acquired by the agile software development community to mainstream software developers working on all kinds of projects. The Extreme Programming community has shown the value of writing automated software unit and acceptance tests for increasing quality, reducing development cost and improving agility. Now that we know this is possible, how can we apply these lessons to more traditional software projects? And if you are an XP developer, how can you improve the way you write tests?

The XUnit family of testing frameworks (including JUnit, SUnit, NUnit, VbUnit, etc.) provide an important first step in software test automation. But test automation is much more than just knowing how to program a test in XUnit. The neophyte test-writer is faced with a deluge of questions and issues; e.g.,

  • What should I be testing?
  • How many tests are enough?
  • What should I focus on while writing my tests?
  • How do I test my tests?
  • How can I make my tests more understandable?
  • How do my tests relate to use cases?
  • How can I make my software easier to test?

This tutorial addresses these and many other questions.

Attendee background

This tutorial is intended for professional software developers who would like to learn how to test their software more effectively.

Prerequisites: Participants must be familiar with the object-oriented software development paradigm, and be fluent in one or more object-oriented languages. Familiarity with Java or C# is useful, but not required. Familiarity with a unit testing framework, such as JUnit, is preferable.

Format

Lecture and hands-on exercises

Presenters

Gerard built his first unit testing framework in 1996 and has been doing automated unit testing ever since. Along the way, he has become an expert in refactoring of software, refactoring of tests, and design for testability. Gerard has applied automated unit and acceptance testing on projects ranging from full-on eXtreme Programming to traditional waterfall development. He has presented successful tutorials at the past three OOPSLAs, has organized workshops at four previous OOPSLAs, and has presented papers on developing and testing object oriented software frameworks at two previous OOPSLAs as well as XP2001 and XP2002.

Ralph Bohnet is a senior consultant and trainer with Clearstream Consulting and has been doing agile development since 2000. He is an avid advocate of automated testing and Test First Development. Over the past 13 years of IT experience, he has acted as team leader, mentor, business analyst, OO developer, and instructor. He is currently the team lead of a testing team for a national Railway company. Ralph has been the president of Calgary Java Users Group for the past 4 years.

1 Scrum and Agile Process 101

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

Ken Schwaber, Agile Alliance, ken.schwaber@verizon.net

Agile development processes are different. They increase productivity, and they bring focus and pleasure back to software development. As they move from early adopters to the mainstream, practitioners and researchers require an understanding of their principles and operation. This tutorial explains the underlying theory and practices of all agile processes, and then explains how they are implemented in Scrum. A case study is presented that provides the rules and feel for the various Scrum practices. Then the new management practices and roles demanded by agile processes are explored. To wrap up, various techniques for scaling agile processes to any type of project are presented and examples provided.

Attendee background

Prerequisites: Attendees must understand software development, as demonstrated by participating in development projects.

Format

Lecture

Presenter

Ken Schwaber is Chair of the Agile Alliance. He is one of the developers of the Scrum agile process and is an author of the Agile Manifesto. He has given presentations at numerous conferences and user groups, and is author of "Agile Software Development with Scrum" with Mike Beedle. Ken has developed, managed and consulted about software development for over 30 years.

2 Introduction to Concurrent Programming in Java

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

David Holmes, DLTeCH Pty Ltd, dholmes@dltech.com.au
Doug Lea, State University of New York (SUNY) at Oswego, dl@cs.oswego.edu

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support for concurrency has enticed many to try their hand at building concurrent applications. Concurrent programming poses many traps for the unwary, however.

This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side, we examine Java's mechanisms to support concurrent programming. On the design side, we explore object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems.

Attendee background

This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications.

Prerequisites: Attendees should be familiar with basic OO concepts and must have a working knowledge of the Java programming language.

Format

Lecture

Presenters

David Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.

Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model".

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

4 Introduction to Aspect-Oriented Programming with AspectJ

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

Erik Hilsdale, PARC, hilsdale@parc.com
Jim Hugunin, PARC, hugunin@parc.com

AspectJ is a seamless, aspect-oriented extension to Java™. It can be used to cleanly modularize the crosscutting structure of concerns such as exception handling, multi-object protocols, synchronization, performance optimizations, and resource sharing.

When implemented in a non-aspect-oriented fashion, the code for these concerns typically becomes spread out across the program. AspectJ controls such code-tangling and makes the underlying concerns more apparent, making programs easier to develop and maintain.

This tutorial will introduce Aspect-oriented programming and show how to use AspectJ to implement crosscutting concerns in a concise, modular way. We will also demonstrate and use AspectJ's integration with IDEs such as JBuilder, NetBeans, Emacs, and Eclipse, in addition to the core AspectJ tools.

AspectJ is freely available at http://eclipse.org/aspectj.

Attendee background

Prerequisites: Attendees should have experience doing object-oriented design and implementation, and should be able to read and write Java code. No prior experience with aspect-oriented programming or AspectJ is required.

Format

Lecture and demonstration

Presenters

Erik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has much background in AspectJ.

Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.

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.

6 Eclipse Extensions—Making the Connections

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

Kai-Uwe Maetzel, IBM Research, OTI Labs, kai-uwe_maetzel@ch.ibm.com

Eclipse (http://www.eclipse.org) is an open-source platform for building tools for developers. The platform was designed from the ground-up with extensibility in mind. A scalable plug-in mechanism and a rich set of APIs enables developers to develop and explore new tools quickly, without having to start from scratch.

This tutorial illustrates the full plug-in development cycle by way of an example. You'll explore the Eclipse architecture and become familiar with the basic plug-in mechanism. With this knowledge, you'll write and debug your first plug-in using Eclipse's Plug-in and Java Development Environments. You'll also add extension points to your plug-in to enable others to extend it. You will then package your extensible plug-in as a Feature and publish it with the built-in Eclipse Update Mechanism. Finally, you'll set up and manage an Eclipse Update Site, a place for other Eclipse users to explore new features as well as finding upgrades.

During all these steps, you will learn the underlying Eclipse concepts and design ideas. You'll learn the rules you need to know to make your plug-ins good Eclipse citizens. In addition, you will receive many interesting insights on design challenges in large scale plug-in architectures.

Tutorial participants are invited to bring their laptops and deepen their understanding by implementing practical exercises.

Attendee background

This tutorial is targeted toward developers who are interested in writing their own Eclipse plug-in tools. Developers with an interest in large-scale plug-in architectures will also benefit from the insights into Eclipse.

Prerequisites: Experience with Java™ development is required.

Format

Lecture and exercises at the computer

Presenter

Kai is one of the original committers on the eclipse.org project. He is a member of the Eclipse architecture team and component lead of the Eclipse Text Infrastructure and Editor Components. He is also a member of the development team for the Eclipse Java Development Environment.

7 Programming Internet-Scale Distributed Applications in the 21st Century: BPEL and Beyond

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

Vivek Sarkar, IBM T.J. Watson Research Center, vsarkar@us.ibm.com
John Field, IBM T.J. Watson Research Center, jfield@us.ibm.com

As more and more applications entail interaction among distributed collections of software components, it is becoming increasingly difficult to discern the boundaries between "application", "middleware", "client", and "server". There is an increasing demand for building internet-scale distributed applications, which have the following key characteristics: (a) lack of a single organizational "locus of control" for application development, (b) heterogeneity -- use of a wide variety of languages and systems for each application component, and (c) greater likelihood of system or network failure than in distributed applications interconnected over a local area network.

Despite work on various "infrastructure" standards for Web Services (e.g., SOAP), until recently, there has been little work on programming models directly supporting internet-scale distributed applications. However, in late 2002, the Business Process Execution Language for Web Services standard ("BPEL4WS", or "BPEL"), jointly developed by IBM, Microsoft, and BEA, was released. The name is somewhat misleading -- BPEL is more than a business process specification. It is essentially a high-level programming language, one which addresses some, but not all, of the issues relevant to developing internet-scale distributed applications.

This tutorial will first discuss general issues that arise in building internet-scale applications. Next, we will give a detailed overview of BPEL with examples, showing how BPEL addresses many of these issues. The overview will cover processes, service links activities, containers, scopes, fault handlers, and exception handlers. Finally, we will cover a number of other technologies and standards related to programming internet-scale distributed applications, and discuss their relationship to BPEL.

Attendee background

Prerequisites: Basic knowledge of object-oriented languages, web services, and parallel and distributed computing.

Format

Lecture

Presenters

Dr. Vivek Sarkar is Senior Manager of the Programming Technologies department at the IBM T. J. Watson Research Center. His research interests are in the areas of static and dynamic program analyses and their applications to optimization, parallelization, and programming tools. The projects under way in his department include component verification (Canvas), analysis and optimization of web service and database applications (DOMO), refactoring analysis and transformation (Gnosis), adaptive optimization and memory wall (Jikes RVM), data model extraction from legacy applications (Mastery), and dynamic analysis and datarace detection (Shrike). Vivek obtained his Ph.D. from Stanford University in 1987, and has been a member of the IBM Academy of Technology since 1995.

John Field is a Research Staff Member and manager of the Advanced Programming Tools group at IBM's T.J. Watson Research Center. His research interests include static analysis and verification of programs, tools for program understanding and transformation, program slicing, program semantics and logics, and programming models for distributed systems. In addition to publishing his work in a wide variety of conferences and journals, he has contributed to the development of several IBM products. He received a Ph.D. from Cornell University in 1991.

8 Patterns @ Work

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

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

This tutorial illustrates the application of design patterns by example. We present in detail a real-world system and describe how it is designed with patterns, with a focus on distribution and concurrency, flexibility, and components. In particular, we will re-play the process of the system's construction step by step, discuss the design problems that occur, present one or more patterns that can help to address these problems, discuss which of the alternative patterns we selected and why, and show how we actually applied the selected patterns. This sequence illustrates how the design of the system slowly evolves towards the final architecture. We will also see that using patterns in practice is influenced by many factors: concrete constraints and requirements set by the application under development, limited or overstated understanding of particular patterns, varying developer skills, and also personal preferences. A major lesson that we can learn from this discussion is that there exists no "right pattern" for addressing a particular design problem, but rather, different patterns apply in different situations.

A reflection on the case study leads us to general guidelines and golden rules for applying patterns in practise, and we discuss how these guidelines and rules aid in building high-quality software with predictable properties. The tutorial concludes with a summary of our experiences from several projects in which we applied patterns: what worked, what could be improved, and what we learned.

Attendee background

Prerequisites: Attendees are expected to have sound knowledge of object technology, and basic knowledge of both UML notation and the pattern concept.

Format

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

9 Java Concurrency Utilities: Tools for Managing Multi-threading

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

Doug Lea, State University of New York (SUNY) at Oswego, dl@cs.oswego.edu
David Holmes, DLTeCH Pty Ltd., dholmes@dltech.com.au

Semaphores and mutexes, latches and gates, pools and executors - these are all tools for managing threads within our applications. Each one has its own properties and purpose, and when used correctly, each can greatly simplify concurrent program design.

The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support for multithreading. However, the Java concurrency primitives are just that: primitive. You can build many concurrency utilities from them, but doing so requires great care, as concurrent programming poses many traps for the unwary. Designing concurrent programs that can successfully resolve the competing forces of safety, liveness, efficiency, coordination, and reusability, is a task that can be greatly aided through the use of a good set of tools - a good concurrency utility library.

This tutorial presents the components of a proposed concurrency utility library for the Java platform and being developed under JSR-166. We will look at the purpose and properties of each tool and how it fits into the concurrent design puzzle. We will also look at proposed extensions to the Java concurrency primitives.

Attendee background

This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications in Java.

Prerequisites: Attendees must be familiar with basic OO concepts and have a working knowledge of the Java programming language. Familiarity with Java's threading and synchronization mechanisms is desirable, but not essential.

Format

Lecture

Presenters

Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model".

David Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.

10 Advanced Aspect-Oriented Programming with AspectJ

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

Erik Hilsdale, PARC, hilsdale@parc.com
Jim Hugunin, PARC, hugunin@parc.com

This tutorial will provide involved hands-on programming exercises that both use some of AspectJ's advanced features, and feature AspectJ used in advanced contexts. We will show how AspectJ can be used to solve problems in instrumentation (including logging), testing, quality management, and feature management. In addition, advanced parts of the AspectJ design and implementation will be introduced, along with discussions of possible future features. Exercises will use the core AspectJ tools and IDEs.

AspectJ is freely available at http://eclipse.org/aspectj.

Attendee background

Prerequisites: Knowledge of Java and some familiarity and experience with AspectJ, equivalent to the material covered in tutorial 4.

Format

Lecture and hands-on exercises

Presenters

Erik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has a long history with AspectJ.

Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team, he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.

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

14 An Introduction to the Common Language Infrastructure (CLI)

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

Damien Watkins, Director - Project 42 / Research Associate - DSTC, damien@project42.net

A number of Component-Based Architectures (CBAs) have been developed to facilitate the interoperability of software components that are written in different programming languages. The most widely known and used of these is OMG's Common Object Request Broker Architecture (CORBA) and Microsoft's Component Object Model (COM) and Distributed COM (DCOM). Although not specifically designed to provide language interoperability, many Java-based technologies, such as Enterprise Java Beans (EJB), also adhere to the principles of a CBA. The Common Language Infrastructure (CLI) is the latest CBA to be developed, and it builds on many of the lessons learned from previous architectures.

In this tutorial, we will look at the major components of the CLI. The CLI is an ECMA standard on which Microsoft has built three implementations: the .NET Framework, the Compact Framework and the Shard Source CLI. The CLI is also the specification on which non-Microsoft implementations, such as Ximian's Mono, are based.

Attendee background

Prerequisites: Attendees should have experience programming in an object-oriented programming language. Knowledge of a distributed/component architecture, such as CORBA or COM, is helpful. No familiarity with the CLI is required.

Format

Lecture

Presenter

Dr. Damien Watkins is the founder and Managing Director of the software company "Project 42" and a Research Associate with the Distributed Systems and Technologies Centre. Prior to commencing Project 42, Damien lectured at the School of Computer Science and Software Engineering at Monash University. Damien is the primary author of "Programming in the .NET Environment" (Addison-Wesley 2003) and several papers on COM/DCOM, CORBA and the .NET Framework. Damien has presented tutorials on software architectures at OOPSLA 2002, SIGCSE 2002, TOOLS Pacific/Europe and the Microsoft Research Faculty Summit 2001/2002.

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.

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

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

Douglas Schmidt, Vanderbilt University, d.schmidt@darpa.mil

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

Format

Lecture

Presenter

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.

20 The C# Programming Language

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

Anders Hejlsberg, Microsoft Corporation, andersh@microsoft.com

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.

Format

Lecture and working code demonstrations

Presenter

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, R.E.Jones@ukc.ac.uk
Eric Jul, University of Copenhagen, eric@diku.dk

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.

Format

Lecture, animations, and demonstrations

Presenters

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, Frank.Buschmann@siemens.com
Kevlin Henney, Curbralan Ltd., kevlin@curbralan.com

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.

Format

Interactive lecture

Presenters

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, fowler@acm.org

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.

Format

Lecture

Presenter

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

26 Patterns for High Performance Systems

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

Robert Hanmer, Lucent Technologies, hanmer@lucent.com

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.

Format

Lecture

Presenter

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, kim@cs.williams.edu

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.

Format

Lecture

Presenter

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, formani@us.ibm.com
Nate Forman, Ticom Geomatics, nforman@austin.rr.com

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.

Format

Lecture

Presenters

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, woolf@acm.org
Gregor Hohpe, ThoughtWorks, Inc., gregor@hohpe.com

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.

Format

Lecture

Presenters

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, jeff@crystalclearsoftware.com
Richard Anthony, General Dynamics Decision Systems, Richard.Anthony@gd-decisionsystems.com

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.

Format

Lecture and discussion

Presenters

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

42 Agile Use Cases

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

Alistair Cockburn, Humans and Technology, alistair.cockburn@acm.org

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.

Format

Lecture and discussion

Presenter

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 http://Alistair.Cockburn.us.

21 Feature Oriented Programming and Product-Lines

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

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

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

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

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

Attendee background

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

Format

Lecture

Presenter

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

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

37 Dungeons and Patterns!

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

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

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

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

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

Attendee background

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

Format

Role-playing game

Presenters

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

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

38 Project Retrospectives in Agile Development

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

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

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

Attendee background

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

Format

Introductory lecture and simulated retrospective

Presenters

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

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

39 Enterprise Aspect-Oriented Programming with AspectJ

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

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

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

Attendee background

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

Format

Lectures and hands-on exercises

Presenters

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

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

40 An Overview of UML 2.0

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

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

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

Attendee background

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

Format

Lecture

Presenter

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

41 C++ Threading: A Generic-Programming Approach

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

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

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

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

Attendee background

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

Format

Lecture

Presenter

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

43 Program Generation: Concepts and Techniques

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

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

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

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

Attendee background

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

Format

Lecture and live demonstrations

Presenter

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

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.

47 Enterprise Application Integration with J2EE and .NET

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

Ian Gorton, Pacific Northwest National Laboratory, ian.gorton@pnl.gov
Anna Liu, Microsoft Australia, annali@microsoft.com

Creating enterprise-scale information systems poses many challenges, as such systems require integrating multiple (legacy) applications in such a way as to streamline and automate internal business processes and provide web-enabled business functions. The underlying architectures for such systems are embodied in a range of diverse products known as Enterprise Application Integration (EAI) technologies.

This tutorial introduces EAI. It highlights some of the major issues in EAI technology selection, application design, and deployment. It introduces service-oriented architectures as a means of EAI, and presents some common architecture patterns for accomplishing EAI using J2EE and .NET. J2EE components covered will include the Java Messaging Service, Java Connector Architecture and supporting application server technology. In .NET, BizTalk, Web Services and various XML technologies will be described and illustrated. We will conclude with a detailed comparison of the strengths and weaknesses of J2EE and .NET technologies for EAI.

Attendee background

Prerequisites: A solid understanding of object-oriented programming languages, such as Java, C++, or C#. Familiarity with the key features of distributed component technologies and enterprise platforms (e.g., J2EE, .NET) is useful but not required.

Format

Lecture and demonstrations

Presenters

Ian Gorton is chief architect in information sciences and engineering at the US Department of Energy's Pacific Northwest National Laboratory. His research interests include software architectures, particularly large-scale, high-performance information systems that use commercial off-the-shelf (COTS) middleware technologies. Dr. Gorton received a PhD in Computer Science from Sheffield Hallam University.

Anna Liu is an enterprise architect with Microsoft Australia. Her research interests include software architectures, patterns and best practices, and COTS software-evaluation and acquisition methods. Dr. Liu holds a BEng (with honors) and a PhD in computer engineering from the University of New South Wales, Australia.

48 Guided Inspection of UML Models

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

John McGregor, Clemson University, johnmc@cs.clemson.edu

There is widespread agreement that finding defects as early in the development life cycle as possible is cost effective; however, there are few systematic techniques for accomplishing this goal. Guided inspection is an inspection technique that is "guided" by test cases. By constructing a "complete" set of test cases, the guided inspection technique identifies elements missing from the model, and it also evaluates the quality of those that are present. This tutorial illustrates the technique using design models created using the Unified Modeling Language. Checklists designed for use at various points in a typical development process assist the inspector in selecting the most effective test cases.

Guided Inspection has several benefits:

  • Objectivity - systematically selects test cases to give all portions of the model equal coverage.
  • Traceability - links the faults detected back to specific requirements.
  • Testability - identifies portions of the design that are complex and require much effort to test.

After taking this tutorial, participants will be able to:

  • define test scenarios from use cases.
  • apply these test cases to an actual system model.
  • adapt the technique and checklists to the maturity of a specific model.

Attendee background

Prerequisites: Attendees should be familiar with UML. It will be helpful if attendees have participated in software reviews and inspections previously.

Format

Lecture and exercises

Presenter

Dr. John D. McGregor is a partner in Luminary Software and an associate professor of computer science at Clemson University. He conducts research, teaches graduate software engineering courses, and serves as a consultant to companies in several domains. Dr. McGregor has conducted research for organizations such as the Software Engineering Institute, National Science Foundation, DARPA, IBM and AT&T. He has applied those research results on projects in telecommunications, insurance, and financial institutions. He is co-author of "A Practical Guide to Testing Object-Oriented Software," published by Addison-Wesley. Dr. McGregor's current research interests include software product lines, design quality, testing and measurement.

49 Extending Enterprise Systems with Mobile/Wireless Applications

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

James White, Fourth Generation, Inc., jpwhite_mn@yahoo.com

Many organizations are adding mobile and wireless capabilities to their IT infrastructure. This tutorial explores technologies, designs and issues associated with the development of mobile and wireless software applications. In this tutorial, we explore how to leverage and reuse existing object-oriented system code for mobile and wireless applications. We also identify the pros/cons and development issues associated with various software application solutions, including Java, .NET, Wireless Application Protocol (WAP), and Brew. We examine the device market and its impact on software development. Finally, we discuss what makes for good and bad mobile/wireless software. Not unlike enterprise software, mobile/wireless software solutions must be appropriately designed. Some of the design and architecture issues are shared with those of bigger object-oriented applications. Other issues, especially around user interface and database synchronization, require special consideration. This tutorial exposes the mobile/wireless software architecture and design issues and potential solutions.

Attendee background

This tutorial is targeted to those individuals exploring mobile/wireless software application development.

Prerequisites: Participants should have some familiarity with the basic concepts of software development and object-oriented programming.

Format

Lecture, examples, and demonstrations

Presenter

James White is Wireless Practice Manager and Senior Consultant for Fourth Generation, Inc. based in St. Paul, MN. He is the co-author of "Java 2 Micro Edition" from Manning Publications and has written several articles on mobile/wireless computing, Java and object-oriented topics. Jim also finds time to speak frequently at industry conferences and spoke about J2ME at last year's JavaOne conference.

50 Understanding Circa-2003 XML Technologies

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

Don Box, Microsoft Corporation, dbox@microsoft.com

XML has grown out of the world of document management to become a broadly applicable technology that has impact on storage, messaging, and programming languages. This tutorial will look at the current landscape of XML technologies that are used to transmit, traverse, and transform XML-based information, with an emphasis on how these technologies impact current programming environments. Topics to be discussed include:

  • The XML Data Model(s)
  • Traversal: Imperative vs. Declarative
  • Transformation and Projection: XSLT and XML Query
  • Datatypes in XML: XML Schema Part II
  • Structural types in XML: XML Schema Part 1, Relax NG
  • XML Messaging: SOAP
  • Behavioral typing in XML: Web Services
  • Nominal typing in XML: RDF and WS-Policy

Attendee background

Attendees should have a basic familiarity with two or more type systems used in modern programming environments.

Format

Lecture

Presenter

Don Box is an architect on the XML Messaging team at Microsoft, where he works on defining and implementing the web service protocol stack. Don co-created the Simple Object Access Protocol (SOAP) and has helped develop SOAP-based technologies such as WS-Policy, WS-Reliable Messaging and WS-Addressing. Don has written several books on component technologies for Addison Wesley, beginning with "Essential COM," and most recently, "Essential .NET."

51 Designing Reliable Collaborations

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

Rebecca Wirfs-Brock, Wirfs-Brock Associates, rebecca@wirfs-brock.com

Software need not be impervious to failure. But it shouldn't easily break. A large part of software design involves building our software to accommodate situations that, although unlikely, still have to be addressed. Once you've decided on the basic architecture of your system, assigned responsibilities to objects, and designed collaborations, you can take a closer look at making specific collaborations more reliable--by designing objects to detect and recover from exceptional conditions. This tutorial covers reliable collaboration design from A to Z. Topics include: resolving the mismatch between use case and program level exceptions, check-and-act and try-and-see exception recovery strategies, objects that are naturally suited for taking on exception-handling responsibilities, and how to streamline error checking by identifying trusted collaboration regions and designing for trusted and untrusted collaborations. We'll also present guidelines for naming exceptions and common exception-handling traps to avoid.

Attendee background

Prerequisites: Attendees should be familiar with object-oriented design and programming.

Format

Lecture with many examples, case studies, and guidelines based on real-world experiences and projects

Presenter

Rebecca Wirfs-Brock is a world-renowned innovator in practical object analysis and design techniques. She is lead author of the new book, "Object Design: Roles, Responsibilities and Collaborations" (Addison-Wesley 2003). She invented the set of development practices known as Responsibility-Driven Design. Most recently, she has focused on ways to effectively communicate design ideas, designing flexible software without over- or under-engineering a solution, and effective ways to think through design alternatives. Among her widely used innovations are use case conversations and object role stereotypes. She specializes in the transfer of object analysis and design expertise through mentoring, consulting, and training.

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.

55 J2EE in Practice: Architectural Variations in the Context of Enterprise Systems

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

Markus Völter, independent consultant, voelter@acm.org
Arne Koschel, IONA Technologies GmbH, arne.koschel@iona.com

J2EE serves as a reference architecture for enterprise applications. It has gained widespread use over the past few years. For each part of a multi-tier enterprise application, J2EE provides both an implementation technology and a blueprint of how it should be used.

Unfortunately, it is not always easy determine which J2EE technology to use in a given context, or how to use it. This tutorial explores different architectural alternatives available to developers when working with J2EE and describes when it is and is not appropriate to use each one. These guidelines are taken from experiences using J2EE for real-world, mission-critical applications.

Attendee background

Prerequisites: Attendees should have some experience with using J2EE and possess a basic understanding of what the different constituents of J2EE are used for.

Format

Lecture and discussion

Presenters

Markus Völter works as a freelance consultant for software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular Speaker at Conferences and co-author of Wiley's "Server Component Patterns - Component Infrastructures illustrated with EJB."

Over the last couple of years, Markus has architected, coached and implemented on several J2EE systems in various domains (banking, diagnostics, automotive) and on various scales (ranging from 10 developers and 400 concurrent users up to 120 developers and 50,000 users).

Dr. Arne Koschel works world-wide as Technical Product Manager and Product Specialist for IONA's Orbix Application Server Platform (ASP). Previously, he worked as independent Senior Object Technology Consultant and Enterprise Software-Architect with assignments throughout Europe and the United States. One of his major involvements (system architecture) for an Online Brokerage Application was selected as the major JavaOne 2001 J2EE customer success story. He is a regular speaker at conferences world-wide and author of many publications. He also cooperates with Universities, where he teaches courses in the areas of middleware and active databases.

56 Model-Driven Architecture

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

Krzysztof Czarnecki, University of Waterloo, czarnecki@acm.org
Petter Graff, Inferdata Corporation, petter@inferdata.com

Today, application development remains a laborious process, with relatively little reuse or automation. Application programmers must manually map their high-level analysis models to target platform architectures, such as J2EE and .NET, and eventually, to code. Rather than focusing on the problem domain, they have to deal with the complex details of the target platforms. The analysis and design models - being just additional documentation artifacts - are often not properly maintained in the face of approaching deadlines. This makes the applications hard to evolve later. Retargeting an application to a new platform is almost as difficult as writing it from scratch. Model-Driven Architecture (MDA) is a framework for model-based development being standardized by the Object Management Group (OMG) that addresses these problems. In MDA, models are the primary source of an application. All other artifacts, such as code, tests, and documentation, are (mostly) automatically derived from models.

In this tutorial, we will take a critical look at the promises made by MDA and clearly distinguish what is possible today from the visions of tomorrow. After explaining basic MDA concepts, such as metamodeling and model transformations, we'll discuss tool requirements and review some existing MDA tools. We'll round up the tutorial with a demonstration of generating a complete J2EE and .NET application from the same high-level UML model.

Attendee background

Prerequisites: Attendees should have basic knowledge of UML.

Format

Lectures and demonstrations

Presenters

Dr. Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as seminal work of the area and is used as a graduate text at universities around the world. He is General Chair of the 2003 International Conference on Generative Programming and Component Engineering (GPCE). His current research focuses on realizing the synergies between GP and model-driven architectures.

Petter Graff is Vice President of InferData Corporation. He has developed object-oriented systems for more than 20 years. At InferData, his focus is in object-oriented component development, software architectures and advanced implementation techniques for enterprise applications. He created one of the first model transformation tools (MCC) and is currently responsible for the development of InferData's next generation agent-based model transformation tool. Petter is also coauthoring an upcoming book on Model Driven Development (estimated to be published fall 2003).

57 Test-Driven Development Workout: Building Java Muscle

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

William Wake, Software Coach, William.Wake@acm.org
Steve Metsker, Reader, Thinker, Writer, and Teacher, Steve.Metsker@acm.org

Programming skills are back in style!

Test-driven development is based on a cycle of testing, coding, and refactoring. The meat of this session is a real-time workout where you explore and exercise your skills in techniques that build rippling muscles for Java developers.

Whether you want to become a bodybuilding champion or a top-drawer developer, choice of regimen is critical. For developers, writing the tests first changes the way you design, improves the quality of your code, and guarantees your code is testable.

Like a bodybuilder's high-protein diet, refactoring shows you how to take code that merely works, and turn it into lean, easy-to-understand code that you'll be proud of.

This tutorial cranks up the workout intensity with pair programming (a form of spotting), a contest, and prizes, all designed to maximize your sweat equity in building your Java muscle.

This class is for Java programmers only. Bring a laptop if you can, with a Java environment and JUnit installed and working. If you don't have a laptop, that's cool--we'll pair you with someone who does. Either way, please contact William.Wake@acm.org and tell him whether you're pumping your own iron or need to share.

Attendee background

Prerequisites: Attendees must be able to program in Java.

Format

Lecture and hands-on exercises with partners

Presenters

William Wake is an independent consultant interested in agile methods, patterns, and human-computer interaction. He is the author of "Extreme Programming Explored" and the "Refactoring Workbook."

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

58 Object-Oriented Modelling with UML

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

Brian Henderson-Sellers, University of Technology, Sydney, brian@it.uts.edu.au
Magdy Serour, University of Technology, Sydney, mserour@it.uts.edu.au
Cesar Gonzalez-Perez, University of Technology, Sydney, cesargon@it.uts.edu.au

This tutorial introduces the UML (Unified Modeling Language) through the concepts of modelling. Having explained why it is useful to think about modelling before coding, the basic modelling concepts and notations of the UML are introduced, with focus on class diagrams and relationship modelling. More detailed topics are also considered: responsibilities, stereotypes, interfaces, roles, types, components and packages, dependencies, interaction diagrams, statechart diagrams and use cases.

Attendee background

Prerequisites: Knowledge of OO concepts will be beneficial; no knowledge of methodologies or modelling is required.

Format

Lecture

Presenters

Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research (COTAR) and Professor of Information Systems at University of Technology, Sydney (UTS). He is author of eleven books on object technology and is well-known for his work in OO methodologies (MOSES, COMMA, OPEN, OOSPICE) and in OO metrics. Professor Henderson-Sellers has contributed as a member of the Review Panel for the OMG's Software Process Engineering Model (SPEM) and the UML 2.0 review team. In July 2001, Professor Henderson-Sellers was awarded a Doctor of Science (DSc) from the University of London for his research contributions in object-oriented methodologies.

Magdy Serour is a Research Fellow at the Centre for Object Technology Applications and Research at University of Technology, Sydney (UTS). He is the co-founder of SB the Software Group Pty Ltd (1982) and has had 25 years of experience in Information Technology, being significantly involved in Object technology adoption, process engineering, requirement engineering, modelling, implementation and IT consulting. At the moment, he is working in software process improvement and capability determination for object oriented/ component based software development (OOSPICE).

Cesar Gonzalez-Perez is a post-doctoral research fellow at the Faculty of Information Technology at UTS, where he works on object-oriented methodologies. He is the founder and former technical director of Neco, a company based in Spain specialising in software development support services, which include the deployment and use of OPEN/Metis at small- and mid-sized organizations. He has also worked for the University of Santiago de Compostela in Spain as a researcher in computing and archaeology, and was awarded a PhD in this topic in 2000.