Responsibility-Driven Design offers practical advice for designing, implementing, and redesigning with responsibilities. In a responsibility-based model, objects play specific roles and occupy well-known positions in the application architecture. Each object is accountable for a specific portion of the work. They collaborate in clearly defined ways, contracting with each other to fulfill the larger goals of the application. By creating a “community of objects,” assigning specific responsibilities to each, we build a collaborative model of our application. Objects are more than simple bundles of logic and data ... they are service-providers, information-holders, structurers, coordinators, controllers, and interfacers to the outside world! Each must know and do its part! Thinking in these terms enables you to build powerful, flexible applications. This tutorial, which includes new material from our forthcoming book, will be an example-based tour of Responsibility-Driven Design. It presents our latest innovations and practical techniques. Topics include: finding and evaluating the qualities of candidate design objects, mapping roles to classes and interfaces, strategies for assigning object responsibilities, deciding on the control style of an application, effective ways to describe collaborations, how to organize a design by specifying contractual relations and obligations, and techniques for increasing a design’s flexibility and clarity. Attendee Background: Participants should be familiar with object concepts and be looking for practical techniques, guidelines and a design process that emphasizes modeling the behavioral aspects of a software system. Presenters: Rebecca Wirfs-Brock is president of Wirfs-Brock Associates, a firm specializing in the transfer of object analysis and design expertise to organizations and individuals through training, mentoring, and consulting. Rebecca has been involved with object technology since its infancy. She is the inventor of the set of development practices known as Responsibility-Driven Design. From development on the Tektronix implementation of Smalltalk in the early 1980s, through years of development and training experience, she is recognized as one of only a few knowledgeable and influential practitioners of object-oriented design. She spent 17 years as a Software Engineer at Tektronix, where she managed the first commercial Smalltalk effort and was the technical lead for the development of Color Smalltalk. Recently, she has authored use cases for a telecommunications framework and an online banking system and has mentored teams in use case writing, design, architecture and managing incremental, iterative object-technology projects. She practices what she teaches! Alan McKean is Vice President and Director of Educational Services at Wirfs-Brock Associates. Alan McKean has devoted most of his career applying principles of design and adult learning to find better ways to communicate technical and design information. A student of R. Buckminster Fuller and a graduate of the University of Oregon with a Masters in Computer Science, he specializes in system architecture and object-oriented design and programming. Alan has delivered over a hundred workshops on designing and programming object-oriented software during his 10+ years at Instantiations, Digitalk, and Wirfs-Brock Associates. Alan was a keynote speaker at the OOPSLA Educator’s Symposium in 1995 and has been invited to speak at this year’s Educators’ Symposium. Prior to his training experience, Alan was a Director at Dynamix, Inc., a computer game company, where he invented and developed a toolset for synchronizing animated images with actors’ recorded voices and a suite of Smalltalk-based tools for managing computer game sound effects and music.

The use of object-oriented software construction techniques and iterative, incremental processes influence the organization, structure, and execution of testing activities in a project. The techniques presented in the tutorial are intended to provide a scalable process that can be tailored to the size of a project and the criticality of the type of application. The comprehensive test plan, presented in the tutorial, integrates the construction process and the testing process to produce an efficient and complete development process. This tutorial is divided into three parts: (1) specific techniques supported by small examples to illustrate specific testing algorithms, (2) techniques for testing system level models using enhanced inspection and review procedures and (3) a process for system testing presented within the context of a complete testing process for object-oriented systems. Instructional objectives: The participant will be able to define test cases from use cases. The participant will be able to build test suites that reuse test cases from related uses. The participant will be able to adapt a generic testing process to his/her corporate and project environments. The participant will be able to prioritize tests based on information in the use cases. Lecture/discussion: 70% Exercises: 30% Attendee Background: Attendees should be familiar with object-oriented concepts and at least one object-oriented programming language. It will be helpful if the attendee is familiar with basic software testing techniques to the level gained by practical experience. Presenter: Dr. John D. McGregor is a senior partner in Korson-McGregor and an associate professor of computer science at Clemson University. Dr. McGregor has conducted funded research for organizations such as the National Science Foundation, DARPA, IBM, and AT&T. Dr. McGregor has developed testing techniques for object-oriented software and developed custom testing processes for a variety of companies. Dr. McGregor is co-author of Object-oriented Software Development: Engineering Software for Reuse (Van Nostrand Reinhold) and is co-author of A Practical Guide to Testing Object-Oriented Software (Addison-Wesley, 2001). He writes a column on Testing and Quality for the Journal of Object-oriented Programming (JOOP) published by SIGS Publishing. He has published numerous articles on software development focusing on design and quality issues. Dr. McGregor’s research interests include software engineering specifically in the areas of process definition, design quality, testing and measurement. Dr. McGregor has given tutorials for several years at OOPSLA and ECOOP. He presents to 10 - 12 conferences per year as well as offering industrial courses to demanding technical audiences.

Agile processes and lightweight methods are increasingly popular but share with their ponderous predecessors an inattention to usability and user interface design. Usage-centered design is a proven industrial-strength process for designing highly usable and innovative solutions to interaction-intensive problems. It has been applied with marked success to projects ranging from automation programming tools to classroom information systems to e-commerce Web sites. Through alternating lectures, applied exercises, and discussions, this tutorial introduces a streamlined process for quickly and efficiently designing improved user interfaces supported by robust internal software. Essential use cases—a simplified, generalized, and abstract improvement on conventional use cases—are used to model tasks and to guide the design of user interfaces that effectively support the real needs of users. Through actual application to a compressed but representative case study problem, participants will learn, how to employ ordinary index cards and accelerated modeling sessions to quickly understand and prioritize user roles and user tasks and to organize the needed user interface contents. The emphasis will be on modeling techniques that yield the greatest payoff from the least effort in design, techniques that are well-suited to producing world-class designs through iterative, time-boxed development within compressed release cycles. Attendee Background: Some experience with use cases and familiarity with the basic concepts and techniques of object-orientation are assumed. Understanding of the basic principles of usability and user interface design would be helpful but is not mandatory. Presenters: Larry Constantine is Adjunct Professor of Computing Sciences, University of Technology, Sydney, and Director of Research and Development for Constantine & Lockwood, Ltd., the international design and consulting firm he co-founded. A pioneer of modern software engineering practice and a recognized authority on the human side of software, he is the co-inventor of essential use cases and usage-centered design. He has conducted hundreds of seminars and tutorials in nineteen countries and his publications include sixteen books and nearly 150 papers. Dr. James Noble is a lecturer at the Victoria University of Wellington, New Zealand, and a Consulting Associate with Constantine & Lockwood, Ltd. He is the co-author of Small Memory Software: Patterns for Systems with Limited Memory (Addison-Wesley 2000), and numerous published papers on software design, user interface design, and design patterns. He has extensive lecturing and teaching experience, including tutorials at OOPSLA, TOOLS Pacific, and OzCHI.

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 tutorial has two major parts: Part 1 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, such as object, instance, class, interface, attribute, service, message passing, hierarchy, inheritance, polymorphism, late binding, memory management, access specification, and packaging. Part 2 then compares the major object-oriented programming languages: C++, Java, Smalltalk, 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 (to that effect, I have a small case study program, that will be solved in all languages). Whether and how each language supports advanced concepts, like multiple and repeated inheritance, genericity, interfaces, is discussed in detail. Attendee Background: Attendees are 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. Presenter: Raimund K. Ege is an Associate Professor of Computer Science at the Florida International University, Miami. He is author of Programming in an Object-Oriented Environment (Academic Press, 1992), and Object-Oriented Programming with C++ (Academic Press, 1994). 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 tutorials at major conferences (OOPSLA, ECOOP, TOOLS). The tutorials were consistently rated highest and won praise from organizers and attendees.

Even if a software development project creates extensive and complete object-oriented analysis and design models, it will still be perceived as a failure if the user interface is poorly constructed. To be perceived as truly successful, the system must meet the needs of the user. This is best done by designing a user interface that is effective, appealing, intuitive, and easy to learn. In other words, you must create a highly usable object-oriented user interface. Participants of this tutorial will learn how to design highly usable object-oriented user interfaces using the latest in lo-fi prototyping techniques by creating such designs in small groups. Upon completion of this tutorial, participants will be able to: define usability and its relation to object technology; define the role of lo-fi and hi-fi prototyping; design and test lo-fi prototypes according to timeless principles of usability; and implement lo-fi prototypes in a manner that is consistent with the underlying domain model. Attendee Background: Participants should have a basic knowledge of object-oriented analysis and design, use cases, and scenarios; and be involved in the design and implementation of a project utilizing a graphical user interface. Knowledge of a specific object-oriented programming language is not required. Presenter: Luke Hohmann is an independent consultant, committed to coaching his clients to greater levels of performance. Mr. Hohmann is author of Journey of the Software Professional: A Sociology of Software Development (Prentice-Hall), as well as numerous articles on software engineering management. A skilled instructor and speaker, Mr. Hohmann has been invited to many conferences. Mr. Hohmann can be contacted through e-mail at LukeHohmann@yahoo.com.

In this tutorial we examine the secrets of high-quality software architectures: how are they specified, what are their properties, and how are they implemented. The result is a set of principles consisting of methodological steps, concrete design goals that help constructing and implementing software architectures successfully as well as a set of properties that such architectures expose. To illustrate these steps, goals, and properties we use a running example from the industrial automation domain. Attendee Background: Sound knowledge in Object Technology. Presenter: Frank Buschmann is a software engineer at Siemens Corporate Technology in Munich, Germany. His research interests include Object Technology, Application Frameworks, and specifically Patterns. Frank has been involved in several concrete industrial software development projects. Frank is co-author of Pattern-Oriented Software Architecture – A System of Patterns.

“Dungeons and Patterns” is a hands-on tutorial for exploring and learning about design patterns. Learning design patterns will help you become a more powerful object-oriented developer. Unfortunately, a single reading of Design Patterns won’t magically implant design pattern recognition skills in your brain. You have to learn patterns by doing, which means you have to start applying patterns before you can apply them–a monstrous dilemma! The solution is to practice patterns in a playful setting where slip-ups are profitable and painless. In this tutorial you will join an adventure with others at your table, seeking the treasure of patterns hidden within a dungeon replete with structural traps, motivational pitfalls, and implementation monsters. These barriers will succumb to strong collaboration with your table-mates and will yield to effective application of the patterns in Design Patterns. Dungeons and Patterns will deepen your understanding and strengthen your skills at recognizing and applying design patterns. Attendee Background: Attendees should have tried reading Design Patterns at least once. No experience with role-playing games is required. Presenters: Steve Metsker is a researcher and author who explores and writes about ways to expand the abilities of developers. Steve’s articles have explained how to maintain relational integrity in object models, how to solve logic puzzles in Java, and how the conception of “object” differs between Plato and the OO languages. Steve’s most recent publication is the book, Building Parsers with Java. William Wake is interested in XP, patterns, human-computer interaction, and information retrieval. He is the author o, Extreme Programming Explored, and the inventor of the Test-First Stoplight and the XP Programmer’s Cube.

A use case is a way of describing the required behavior of a system, centered around what the system offers its users. Use cases are easy to read, and simple in concept, but surprisingly tricky to write. This tutorial is for the beginning use case writer, to see what a use case looks like, the basics of how to write one, and how to organize people to write, review and use them. The tutorial will be part lecture, and part hands-on exercises. Attendees will brainstorm a list of use cases for a system, write a main scenario, and uncover failure scenarios. The exercises are designed to allow the attendees to practice the writing skills, and discover where use cases get difficult. At the end of the tutorial, the attendee will have the basic vocabulary of use cases, will have seen examples of good and bad ones, and will have experienced the variations in writing that will show up in real use cases. Attendee Background: This tutorial is for people just beginning to write or consider use cases. No particular background is required. Presenter: Alistair Cockburn is a highly regarded instructor and is known as one of the premier experts on use cases. His book, Writing Effective Use Cases, set the standard in the area and was nominated for Software Development’s Jolt book award in 2001. Alistair 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://members.aol.com/acockburn, http://crystalmethodologies.org and http://usecases.org.

Object-oriented design methods are claimed to reduce the gap between the problem domain and the software system. This has important implications for the design of human-computer interaction: A software model that mirrors the real world should reduce the cognitive distance between how a system works and the mental models that users build to use and understand the software. This tutorial explores how to apply object-oriented thinking to the design of human-computer interaction. The methods discussed are part of a general scenario-based framework for usability engineering. In this framework, a scenario is a narrative of the goals, actions, and reactions of actors pursuing goals with an interactive system. The tutorial presents scenario-based techniques for developing and integrating object-oriented views of requirements, activity design, user interface design, and usability evaluation. Throughout, design rationale is captured, serving to raise and discuss the implications that object-oriented concepts will have for the user experience. Concepts and techniques are introduced briefly, then illustrated with examples. The format will be lecture interspersed with presentation and discussion of the examples. Attendee Background: General knowledge of object-oriented concepts, interest in use-centered design of interactive systems. Presenter: Mary Beth Rosson is an associate professor of computer science at Virginia Tech. She is an expert in human-computer interaction (HCI), and the author of numerous research papers on the relationship between HCI and object-oriented design. Rosson has given research papers and tutorials at the ACM SIGCHI, OOPSLA, and ECOOP conferences and has served in many leadership positions in SIGCHI and SIGPLAN. Most recently, she was General Chair of OOPSLA 2000.

Many people who have attended OOPSLA or other conferences find new ideas that they wish to take back to their organizations, but then struggle to make something happen. This tutorial will help participants understand what successful change agents have learned while attempting to introduce new ideas into their organizations. The lessons learned have been documented in an evolving pattern language titled Introducing Patterns (or any new idea) into Organizations. This session will examine the problems and solutions documented in this language through the simulation of attempts to introduce a new idea, such as patterns, into an organization. Attendee Background: Anyone in the software business who is trying to introduce patterns (or any new idea) into an organization will find this tutorial useful. We assume that attendees are familiar with the notion of patterns. Presenters: Mary Lynn Manns is on the faculty at the University of North Carolina at Asheville. During the past three years, she has studied the issues in introducing patterns into organizations. She has also taught patterns in industry and done numerous other presentations on the topic. 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 Software.

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java’s support of concurrency has enticed many to try their hand at concurrent applications. However concurrent programming poses many traps for the unwary. This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side we look at Java’s mechanisms to support concurrent programming. On the design side we look at object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems. Participants will acquire comprehensive knowledge of the concurrency support provided by the Java language and core classes, as well as insight into some threading issues within the Java libraries. They will be exposed to a range of design approaches to assist them in developing safe, concurrent applications in Java and other object-oriented languages. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is assumed that the attendee is familiar with basic OO concepts and has a working knowledge of the Java programming language. Presenters: David Holmes is a Senior Research Scientist at the Cooperative Research Centre for Enterprise Distributed Systems Technology (DSTC Pty, Ltd.), in Brisbane, Australia. He completed his Ph.D. in the area of synchronization within object-oriented systems and has been involved in concurrent programming for a number of years. He is a co-author of the third edition of the Java Series book, The Java Programming Language. 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.

In the past two years, a wide range of publications (Software Development, IEEE Software, Cutter IT Journal, Software Testing and Quality Engineering, and even the Economist) have published articles on what Martin Fowler calls the New Methodologies. There has been a rapidly rising interest in these new approaches to software development such as Extreme Programming, Scrum, Adaptive Software Development, Feature-Driven Development, and Dynamic Systems Development Methodology. Furthermore, scores of organizations have developed their own “lighter” approach to building software. Recently, representatives from each of the New Methodologies met, formed the Agile Alliance, and developed common purpose and principles to help others think about software development, methodologies, and organizations, in new “more agile” ways. This workshop, given by Jim Highsmith, developer of one of the Agile Methodologies (Adaptive Software Development), and one of the authors of the Manifesto for Agile Software Development, addresses key questions: What are Agile Methodologies? What problem domains do Agile Methodologies address? What are the common principles behind Agile Methodologies? What are the similarities and differences between the various Agile Methodologies? Attendee Background: The tutorial is targeted at software development managers, project managers, and team leaders. Basic project management knowledge will be helpful. Presenter: Jim Highsmith is director of Cutter Consortium’s e-Project Management Practice, president of Information Architects, Inc., and author of Adaptive Software Development: A Collaborative Approach to Managing Complex Systems (Dorset House, 2000). He has 30 years experience as a consultant, software developer, manager, and writer. Jim has published dozens of articles in major industry publications and his ideas about project management in the Internet era were featured in recent issues of ComputerWorld and the Economic Times in India. In the last ten years, he has worked with both IT organizations and software companies in the US, Europe, Canada, South Africa, Australia, Japan, India, and New Zealand to help them adapt to the accelerated pace of development in increasingly complex, uncertain environments.

After solving the problems Y2K and Euro, the last big challenges for Cobol-programmers are over. Therefore most of them have to look for new fields of activity, but these are combined with new programming techniques like object-oriented programming. However, introducing object-oriented programming to old-style programmers is a rather hard task. This tutorial shows how this job was done at BMD Steyr, Austrians leading producer of accountancy software. It is a perfect support for everybody who wants to introduce or teach object-oriented programming. After presenting background information why one should change and how this change should be accompanied, a special course for former Cobol programmers is presented. Experiences, as well as tips and tricks, will round up the presentation. Attendee Background: The participants should have basic knowledge of traditional programming languages like Cobol or PL/I and should have the wish to change to object-oriented programming. Presenter: Markus Knasmüller is head of the software department at BMD Systemhaus, Austrians leading producer of accountancy software. In this position he was responsible for the change of 50 programmers and 5 millions lines of code from COBOL to OOP. He is author of various research papers and books (for example: From COBOL to OOP, dpunkt, 2001) and has experience in teaching object-oriented programming at the university as well as in industry. Markus holds a Ph.D. in computer science and a degree in management information systems.

The word “architecture” often bestows instant importance to pretty powerpoint drawings and vague hand waving. And while e-business demands flexible configuration of components and web-services, those components and services will only plug together if they conform to shared “pluggable” architecture standards. Believing “architecture keeps designers from needless creativity,” we outline a clear definition of architecture and architectural style based on UML packages, patterns, and refinement. Elements and rules of an architectural style are separated from the designs which use them, and component architectures use an abstract component-connector model. Attendee Background: Attendees should be familiar with the UML. Presenter: Desmond D’Souza is founder and president of Kinetium. He is co-author of Objects, Components, and Frameworks With UML: The Catalysis Approach (Addison Wesley 1998), and a respected speaker internationally. He was previously senior vice president of component-based development at Platinum Technology and at Computer Associates. Kinetium provides client solutions that leverage shareable architectures for model-driven development and integration of systems, with a current focus on light-weight modeling architecture and methods. Desmond can be reached at dsouzad@acm.org.

The Simple Object Access Protocol (SOAP) is an XML-based protocol for exposing servers, services, components or objects over the web. SOAP codifies the use of existing technologies such as XML, XML Schema Definition (XSD) language, and HTTP to allow code to be accessed in an interoperable and Internet-friendly fashion. This tutorial covers the following topics: The XML Protocol Stack, the XML Schema Language, HTTP Myths vs. Reality, SOAP Encoding, SOAP Framing, SOAP and Extensibility, Architecture of a SOAP runtime, and Architecture of a SOAP application Attendee Background: Attendees should be familiar with the basics of object-oriented programming and moderately comfortable with some RPC or messaging based technology such as CORBA, DCOM or RMI. Presenter: Don Box is a co-founder of DevelopMentor, a developer services company that provides education and support to the software industry at large. Don’s research interests include component software integration, programming for concurrency, and XML-based serialization and metadata protocols. Don is a series editor at Addison Wesley and is the author of Essential COM, and a co-author of Effective COM, and Essential XML, all from Addison Wesley. Don is a contributing editor and columnist at Microsoft Systems Journal (now called MSDN Magazine) and an occasional contributor to XML.com. Don is also a co-author of the Simple Object Access Protocol specification and a member of the W3C Schemas Working Group. Don has a Master’s Degree in Computer Science from the University of California at Irvine.

Designing object-oriented software is hard, and designing reusable object-oriented software is even harder. Experience shows that many object-oriented systems exhibit recurring structures or “design patterns” of communicating and collaborating objects that promote extensibility, flexibility, and reusability. This tutorial describes a set of fundamental design patterns and, through a design scenario, demonstrates how to build reusable object-oriented software with them. The tutorial covers the roles design patterns play in the object-oriented development process: how they provide a common vocabulary, reduce system complexity, and how they act as reusable architectural elements that contribute to an overall system architecture. Attendee Background: Attendees should understand basic object-oriented concepts, like polymorphism and type versus interface inheritance, and should have had some experience designing object-oriented systems. No prior knowledge of design patterns is required. Familiarity with Java is recommended. Presenter: John Vlissides is a member of the research staff at the IBM T.J. Watson Research Center in Hawthorne, NY. He has practiced object-oriented technology for over a decade as a designer, implementer, researcher, lecturer, and consultant. John is author of Pattern Hatching, co-author of Design Patterns and Object-Oriented Application Frameworks, and co-editor of Pattern Languages of Program Design 2. He has published many articles and technical papers on object-oriented themes in general and design patterns in particular. John is a columnist for Java Report and serves as Consulting Editor of Addison-Wesley’s Software Patterns Series. He has a Ph.D. in Electrical Engineering from Stanford University.

The Java Foundation Classes supply a collection of user interface components. This tutorial attempts to introduce a representative selection of the most common and useful of them, showing how they can be combined to produce effective user interfaces. To accomplish this efficiently it is necessary to start with a representation of the required behavior of the interface and derive the detailed design from it. Objectives: provide an introductory overview of the widgets supplied by the JFC; introduce the usability heuristics and style guides that can be employed in the detailed design of user interfaces; show how State Transition Diagrams (STDs) can describe the required behavior of an interface; introduce the Java event dispatch/ listener model; introduce and illustrate layout management policies; illustrate the use of STD, Class, Instance, Interface Layout and Object Interaction diagram notations; illustrate the realization of detailed three-layer designs in Java; introduce the resource management techniques, which improve the presentation of an interface. Attendee Background: An intermediate level tutorial for attendees who have an initial familiarity with OO concepts and wish to develop further understanding in the context of GUI construction. Most of the exposition is at the source code level. Presenter: Fintan Culwin is a Reader in Software Engineering Education at South Bank University: London specializing in Software Engineering and HCI, particularly in the integration of usability considerations in the earliest stages of production processes. He has published five books, including two on Java, and is currently completing a sixth on the JFC. He has published extensively on Internet issues and has presented sessions on the Web and Java at a series of international conferences including: SIGCSE, BCS HCI, ITiCSE, CHI and OOPSLA.

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java’s support of concurrency has enticed many to try their hand at concurrent applications. Effectively creating and managing concurrency within an application poses many design choices and trade-offs. This tutorial looks at more advanced issues in designing concurrent applications. It describes mechanisms for introducing concurrency into applications (threads, message-passing, asynchronous calls) and different models for application architectures, such as data-flow and event-driven designs. The tutorial also shows how concurrency controls can be abstracted into reusable support classes, and finally discusses how concurrent components and applications should be documented. Participants will learn how concurrent applications can be structured in different ways and how different mechanisms can be used to effect concurrent behavior. They will be exposed to a range of design patterns and techniques for introducing and managing concurrency within their applications and how to create reusable concurrency abstractions. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is expected that the attendee is very familiar with OO concepts and the Java language, and has a good working knowledge of Java’s concurrency mechanisms. 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. David Holmes is a Senior Research Scientist at the Cooperative Research Centre for Enterprise Distributed Systems Technology (DSTC Pty, Ltd.), in Brisbane, Australia. He completed his Ph.D. in the area of synchronization within object-oriented systems and has been involved in concurrent programming for a number of years. He is a co-author of the third edition of the Java Series book, The Java Programming Language.

By learning to write parsers you learn to bridge the gap between computers and the users of your language. You can nestle a new language into any niche, defining how your users interact with computers using text. This workshop introduces the basics of building a language from Sequence, Alternation, and Repetition objects. With these three objects, you can create any syntax-free language. In this session you will spend a large portion of class time writing parsers, using the tools this workshop introduces. You will learn when to create an XML-based language and when to use Java. You will also learn how to design a language and how to generate a working parser from this design. Attendee Background: Attendees should be experienced Java developers. Presenter: Steve Metsker is a researcher and author who explores and writes about ways to expand the abilities of developers. Steve’s articles have explained how to maintain relational integrity in object models, how to solve logic puzzles in Java, and how the conception of “object” differs between Plato and the OO languages. Steve’s most recent publication is the book, Building Parsers with Java.

Over the last couple of years we’ve been building a large J2EE application. One of the biggest lessons we’ve learned is to follow the Extreme Programming (XP) approach to Continuous Integration of our 250+ KLOC system. This session focuses on how we turned a project that needed days of fiddling around to get a build into a project that delivers a fully tested build every hour. We’ll go through our automated testing process using JUnit and Excel based acceptance test driver. We will also talk about a set of open source tools we have developed to automate build processes using Ant. We will explore the code for the tools that connect to the source code control system, run code generators, compile, deploy, test and publish the build. Attendee Background: Participants should be familiar with Java and basic XML syntax. Presenter: Michael is a developer and XP advocate at ThoughtWorks working on a very large J2EE application using XP. After studying physics in college he chose a career in software once he realized that staying up all night in an office is more fun than staying up all night in a lab. Michael wrote labor schedule optimization software in C++ before joining Thoughtworks in 1999.

Design patterns are making the transition from curiosity to familiarity. Now that many people know what they are, they want to know how best to apply them. This tutorial shows how to leverage patterns in the software design process. It reveals the thinking behind pattern application—including when not to use a seemingly applicable pattern. It shows how the right patterns can improve a design and how the wrong patterns can degrade one. Students thus learn to apply design patterns to maximum benefit. Attendee Background: Attendees should be well-grounded in object technology and should be familiar with the design patterns in Design Patterns: Elements of Reusable Object-Oriented Software, by Gamma, et al. Familiarity with Java is recommended. Presenter: John Vlissides is a member of the research staff at the IBM T.J. Watson Research Center in Hawthorne, NY. He has practiced object-oriented technology for over a decade as a designer, implementer, researcher, lecturer, and consultant. John is author of Pattern Hatching, co-author of Design Patterns and Object-Oriented Application Frameworks, and co-editor of Pattern Languages of Program Design 2. He has published many articles and technical papers on object-oriented themes in general and design patterns in particular. John is a columnist for Java Report and serves as Consulting Editor of Addison-Wesley’s Software Patterns Series. He has a Ph.D. in Electrical Engineering from Stanford University.

The Common Language Runtime is a new implementation of many existing ideas in component technology. The CLR is a type-centric multi-paradigm component model and runtime that supports object-oriented programming, interface-based programming, and aspect-oriented programming. This tutorial covers the following topics: Managed Types Vs. Unmanaged Types, Managed Execution Vs. Unmanaged Execution, Programming Language vs. The Runtime, The CLR Type System, Loading and Linking, Runtime Type Management, Context and Remoting, and Web Services Attendee Background: Attendees should be familiar with the basics of object-oriented programming and moderately comfortable with systems-programming issues such as thread and process management. Presenter: Don Box is a co-founder of DevelopMentor, a developer services company that provides education and support to the software industry at large. Don’s research interests include component software integration, programming for concurrency, and XML-based serialization and metadata protocols. Don is a series editor at Addison Wesley and is the author of Essential COM, and a co-author of Effective COM, and Essential XML, all from Addison Wesley. Don is a contributing editor and columnist at Microsoft Systems Journal (now called MSDN Magazine) and an occasional contributor to XML.com. Don is also a co-author of the Simple Object Access Protocol specification and a member of the W3C Schemas Working Group. Don has a Master’s Degree in Computer Science from the University of California at Irvine.

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: Participants will be experienced programmers familiar with basic garbage collection technology (for example having attended the introductory GC tutorial – although there would be some overlap). Basic knowledge of OO implementation would be useful but not essential. 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, storage management and distributed systems. He is 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 an Associate Professor and Head of the distributed systems group at DIKU, the Dept. of Computer Science, University of Copenhagen. He is co-designer and principal implementer of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support including distributed storage management and object-oriented design and analysis. He was Programme Chair for ECOOP`98. He has presented tutorials regularly at OOPSLA and ECOOP.

This tutorial is a chance for practiced use case writers to gather and ask the hard questions. What is the difference between Extends and Includes? What is the difference between a business use case and a system use case? When do we stop drawing pictures and start writing text? What expertise is required in the use case writing team? How do we control the mixed levels of writing across people? Where do I put the UI design, the data descriptions and all the other requirements? Can non-technical people write the use cases? Who reviews the use cases? How do we keep use cases writers from infringing on design? The tutorial is structured as part lecture, part workshop, and part open question-and-answer. The lecture introduces the new Stakeholders & Interests model of use cases, along with the notions of different design scopes and goal levels. The workshop portion gives the attendees a chance to try their hands at resolving certain kinds of frequently occurring problems, to sharpen their skills. The open question-and-answer section allows the attendees to ask questions currently plaguing them at work, and even trade answers and experiences amongst themselves. Attendee Background: Attendees must have written some use cases and be familiar with basic use case concepts. Presenter: Alistair Cockburn is a highly regarded instructor and is known as one of the premier experts on use cases. His book, Writing Effective Use Cases, set the standard in the area and was nominated for Software Development’s Jolt book award in 2001. Alistair 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://members.aol.com/acockburn, http://crystalmethodologies.org and http://usecases.org.

The UML can be used in a simple and consistent way to (a) use a “plug-in” framework approach from business and requirements patterns, through architecture and design patterns, to code, (b) treat “objects” and “use-cases” in a fractal manner, from business to code, with patterns of refinement, (c) specify and design components using “types” and “collaborations,” and (d) define component architectures based on an extensible “kit” of architectural modeling elements. This tutorial shows how UML pattern models can be used in a fractal approach to modeling and design. Attendee Background: Attendees should be familiar with the UML. Presenter: Desmond D’Souza is founder and president of Kinetium. He is co-author of the CATALYSIS Method (Addison Wesley, 1998), and a respected speaker internationally. He was previously senior vice president of component-based development at Platinum Technology and at Computer Associates. Kinetium provides client solutions that leverage shareable architectures for model-driven development and integration of systems, with a current focus on light-weight modeling architecture and methods. Desmond can be reached at dsouzad@acm.org.

Aspect-oriented programming (AOP) is a technique for improving separation of concerns in software design and implementation. AOP works by providing explicit mechanisms for capturing the structure of crosscutting concerns. 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 entire programs. 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 use numerous examples to develop participants’ understanding of aspect-oriented programming through AspectJ. We will also demonstrate AspectJ’s integration with IDEs such as JBuilder 4.0 and Forte4J, and emacs. AspectJ is freely available at http://www.aspectj.org Attendee Background: Attendees should have experience doing object-oriented design and implementation, and should be able to read Java code. No prior experience with aspect-oriented programming or AspectJ is required. Presenters: Gregor Kiczales is Professor of Computer Science and Xerox/Sierra Systems/NSERC Chair of Software Design at the University of British Columbia. He is also a Principal Scientist at the Xerox Palo Alto Research Center, where he leads the group that has developed aspect-oriented programming and AspectJ. The focus of his research is enabling programmers to write programs that, as much as possible, look like their design. Prior to developing aspect-oriented programming he worked on open implementation, metaobject protocols, and the CLOS object-oriented programming language. He is co-author of The Art of the Metaobject Protocol, a key work in computational reflection. He has given numerous invited talks, lectures, and tutorials at conferences, universities, and in industry. Erik Hilsdale is a member of the research staff at Xerox’s Palo Alto Research Center. As a member of the AspectJ project team, he focuses 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 with a long background with AspectJ.

Explore the challenges associated with the development of large-scale, real-life, proprietary, object-oriented, distributed, embedded, and multi-tier software systems, and discuss the path of a new professional discipline: the software architect. The software architect needs to be able to organize software systems, and make strategic design decisions, to achieve business goals related to system availability, security, scalability, survivability, long-lived flexibility, large-scale granularity, data quality and maintenance, system metrics and reports, packaging and delivery mechanisms. These issues are not commonly explored via UML or other popular modeling approaches, but are nevertheless critical to the success of modern software development projects. The teaching style for this tutorial is case-driven, and hands-on in nature. Attendees will be divided into teams to work on architecture problems. Throughout the day, working sessions will be intermixed with instructor lectures, to achieve a participatory learning experience. The goal is that attendees will learn both from the instructors and from each other. As a result, the attendee is assumed to have experience building at least one real-life software system of substantial size. Attendee Background: Attendees should either be currently working as software architects, trying to establish a software architecture practice within their company, or working on software systems where they believe an increased emphasis on architecture is needed. Attendees should have experience building at least one real-world software system of substantial size. Presenters: Jim Doble has worked as software developer, manager, and architect within the telecommunications industry for over 19 years. He started his career with Nortel Networks, primarily working on central office switching systems, spent two years with Allen Telecom developing cellular infrastructure products, recently worked for Motorola, Inc. on software architectures for cellular phones, and is currently employed as a principal engineer at Tavve Software Company, developing network management solutions. In addition to architecture, Jim’s technical interests include patterns, prototyping, and tools development. Gerard Meszaros is an acknowledged expert in software architecture and patterns. He has led or participated in workshops on software architecture at OOPSLA since 1994. He has published patterns in the first three volumes of “Pattern Languages of Program Design.” His clients include Nova Gas Transmission, Tandem Computers, TELUS Communications, Digital Technics, Intelligent Databases, TransCanada Pipelines, DMR, and IBM. He has been invited to speak or participate in panels at OOPSLA, PLOP, and other national and international conferences. Ron Crocker is a Senior Member of Technical Staff in the Network and Advanced Technology department in Motorola, Inc. where he is responsible for cellular system architecture and design. He has over 15 years of experience with object-oriented technologies, starting as a C++ guinea pig.

This tutorial is a working session to help you produce effective use cases for functional requirements. We will go beyond simple examples to deal with many of the issues you will face (and we have faced!) in dealing with different kinds of systems, clients, and developers. We will look at some specific topics, such as how use cases relate to business process models, using generic use cases, distinguishing envisioning from designing, effort estimation from use cases, and system exceptions. We will also look at the process of running use case workshops, and at the relation between use cases and other requirements artefacts such as the business rules catalog and non-functional requirements. Attendees are encouraged to bring specific problems for discussion, supported by shareable documents if possible. Attendee Background: You should have written some use cases and have experience of producing requirements documents. Knowledge of OO would be useful but is not essential. Presenters: Bruce Anderson, Senior Consultant in IBM Component Technology Services, has been using use cases in his consulting work for several years. He has worked with clients in the banking, insurance, petroleum, and telecom industries. Bruce served on the OOPSLA‘98 use case panel, and taught tutorials on use cases at OOPSLA in 1999 and 2000, the latter with Paul. Paul Fertig, Senior IT Architect in IBM Business Innovation Services, has been responsible for requirements gathering and architecture in large services contracts for a number of years. He has worked with clients in the telecom, retail and investment banking industries. Paul co-authored a book on OO applications which has been a key influence on IBM’s world-wide software development method.

Developing software for distributed systems that effectively utilizes concurrency over high-speed, low-speed, and mobile networks is a complex task. This tutorial describes how to apply patterns and frameworks to alleviate the complexity of developing concurrent and distributed communication software. These patterns and framework components have been used successfully by the speaker on production communication software projects at hundreds of commercial companies for telecommunication systems, network management for personal communication systems, Web-based content delivery systems, electronic medical imaging systems, real-time aerospace systems, distributed interactive simulations, and automated stock trading. The tutorial illustrates by example how to significantly simplify and enhance the development of communication software that effectively utilizes concurrency and distribution via the use of: OO design techniques – such as patterns, layered modularity, and data/control abstraction OO language features – such as abstract classes, inheritance, dynamic binding, and parameterized types Middleware – such as object-oriented frameworks for infrastructure middleware (such as ACE) and distribution middleware (such as CORBA ORBs) The material presented in this tutorial is based on the book, Pattern-Oriented Software Architecture: Patterns for Concurrent and Distributed Objects (Wiley 2000), which is the second volume in the highly acclaimed Pattern-Oriented Software Architecture (POSA) series. Attendee Background: The tutorial is intended for software developers who are familiar with general object-oriented design and programming techniques (such as patterns, modularity, and information hiding) fundamental OO programming language features (such as classes, inheritance, dynamic binding, and parameterized types), basic systems programming concepts (such as process/thread management, synchronization, and interprocess communication), and networking terminology (such as client/server architectures and TCP/IP). Presenter: Dr. Schmidt is an Associate Professor in the Electrical and Computer Engineering Department at the University of California, Irvine. He is currently also serving as a program manager the DARPA Information Technology Office (ITO) where he is leading the national research effort on distributed object computing middleware. His research focuses on design patterns, implementation, and experimental analysis of object-oriented techniques that facilitate the development of high-performance, real-time distributed object computing middleware on parallel processing platforms running over high-speed networks and embedded system interconnects. Dr. Schmidt is an internationally recognized and widely cited expert on distributed object computing patterns, middleware frameworks, and Real-time CORBA, and has published widely in top IEEE, ACM, IFIP, and USENIX technical journals, conferences, and books. His publications cover a range of experimental systems topics including high-performance communication software systems, parallel processing for high-speed networking protocols, real-time distributed object computing with CORBA, and object-oriented design patterns for concurrent and distributed systems.

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 industrial source code, developed using object-oriented design methods and languages of the late 80s. These systems exhibit a range of problems, effectively preventing them from satisfying the evolving requirements imposed by their customers. 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 applied on real industrial OO systems to detect and repair problems. In particular, we will discuss issues like tool integration, design extraction, metrics, refactoring, and program visualisation. Attendee Background: Participants should have practical programming experience in at least one OO language (Smalltalk, C++, Java, Eiffel, ...). Familiarity with UML is useful, though not required. Presenters: Serge Demeyer is a professor at the University of Antwerp (Belgium). He served as technical leader for the FAMOOS project and as such has been involved in the organization of several workshops (at ECOOP and ESEC) concerning object-oriented reengineering. He has given tutorials on Object-Oriented Reengineering at both OOPSLA and ECOOP and is currently writing a book reporting on his experience. Stéphane Ducasse is a post doctoral researcher at the Software Composition Group in Berne (Switzerland). He served as technical leader for the FAMOOS project and as such has been involved in the organization of several ECOOP workshops concerning object-oriented reengineering. He has given tutorials on Object-Oriented Reengineering at both OOPSLA and ECOOP and is currently writing a book reporting on his experience.

In this tutorial we present in detail a part of a concrete real-world system and how it is designed with patterns: the representation of physical storage in a warehouse management system as well as the client interface to this subsystem. Step by step we will re-play the process of the system’s construction. We discuss the design problems that occur, present the patterns that could help in solving these problems, discuss design alternatives, and show how we actually applied the patterns we selected. By this we will see how the design of the system slowly grows and evolves towards the final architecture. We will also see and discuss how patterns are applied in practice and how they help 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 did we learn. Attendee Background: Sound knowledge in object technology, basic knowledge of UML notation, basic knowledge of the pattern concept Presenter: Frank Buschmann is software 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.

The methodology of an organization is a social construction that includes the roles, skills, teaming, activities, techniques, deliverables, standards, habits and culture of the organization as it develops software. This tutorial starts with language and constructs needed to evaluate, compare, and construct methodologies. These include precision, accuracy, tolerance, relevance, and scale, along with the nine basic elements of a methodology. Several examples of effective, lightweight, and real methodologies are given, along with commentary on the social setting for each. The tutorial examines the conditions suited to shifting from a lighter to a heavier methodology and the penalty for doing so. The tutorial ends with the presentation of a small family of agile methodologies, optimized for productivity, making maximum use of human, face-to-face communication. Considerations about success and failure in affecting culture are visited again at the end. Learn to identify and diagnose the parts of your organization’s methodology, and learn ways to make it more effective. Attendees should have significant software team experience, preferably but not necessarily OO, and must have used at least one methodology and thought about others. Attendee Background: Experienced developers, team leaders, methodologists, and technology selectors trying to choose or design a methodology for their organization. Presenter: Alistair Cockburn, founder of Humans and Technology, was special advisor to the Central Bank of Norway for object technology and software project management, and the designer of the IBM Consulting Group’s first OO development methodology. His books, Surviving Object-Oriented Projects and Writing Effective Use Cases, have garnered praise from practitioners for being pragmatic and readable. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair’s workshops can be found at http://members.aol.com/acockburn and http://crystalmethodologies.org.

This tutorial will demonstrate Web Services in the .NET Framework. A Web Service is application logic accessible through standard web protocols and data formats. They are an integral part of the .NET Framework. The tutorial will be divided into 2 parts. The first part will focus on how to expose a Web Service for clients to access, and the second part will cover how to consume the exposed Web Service from a variety of clients. Some time will be spent exploring applicable architectures and modeling techniques for Web Services. Throughout the presentation, non-functional requirements will also be considered (e.g. security, authentication, performance, etc.) The tutorial’s objective is to give the audience an intermediate-level introduction to Web Services development in the .NET Framework, as well as design decisions that are pertinent to the programming model. The audience will be exposed to XML, SOAP, UDDI, WSDL, ASP.NET, and C#. This tutorial will be presentation based with code examples. Attendee Background: The target audience will be Software Engineers, although Management will be interested to get a glimpse at Web Services and the different business models that are made possible. Basic understanding of Internet technologies will be helpful. Presenter: Casey Chesnut is Vice President of Technology for iigo, Inc. He specializes in cutting-edge technologies and has most recently been concentrating on Web Services in the .NET Framework. He holds two Masters degrees in software engineering.

Due to the importance of distribution and object technologies, infrastructures for distributed object computing and component-based middleware have become commonplace. However, it is not sufficient to just read the specification of standards such as Java RMI, EJB, or CORBA, and then build applications using these standards. On the one hand, the transparency provided by these platforms helps developers to master the complexity of building distributed systems, but on the other hand, it is necessary to know the infrastructure’s internal architectural design to leverage it efficiently. Unfortunately, the architectural principles behind infrastructures are not documented anywhere. Here, patterns come to our rescue. They do not only enable the solution of recurring problems in software development, but also help us to look inside existing software in order to understand it and leverage it efficiently. Thus, the goal of the tutorial is to show the basic principles behind distributed object computing and component-based middleware. Patterns from existing pattern books will be introduced step-by-step to reveal the overall architecture of these infrastructures. These patterns will not only help to understand middleware, but will also be applicable for the development of any distributed systems. In the first part of the tutorial we use patterns to explain the basic architecture of object-oriented middleware from a user perspective. In the second part we will dive into the internals of middleware frameworks. Attendee Background: Attendees should be familiar with distributed systems. They should have basic experience with Java and C++. Knowledge with patterns is not required. Presenter: Michael Stal works as a Senior Principal Engineer for Siemens Corporate Technology where he is head of the Middleware & Application Integration Team. His main research areas include Object-Oriented Middleware, Patterns, Software Architecture, Web Technologies, and Component-based Software Development. Michael is Siemens representative at the OMG, and former member of the C++ standardisation working group X3J16. He is co-author of the books, Pattern-Oriented Software Architecture - A System of Patterns and Pattern-Oriented Software Architecture - Vol. 2: Patterns for Concurrent and Networked Objects. In addition, he serves as editor-in-chief of the German Java Spektrum magazine. Michael has published articles in many magazines and given talks at many conferences world-wide.

Extreme Programming (XP) is an agile software development method that emphasizes ongoing user involvement, automated testing, and pay-as-you-go design. This tutorial introduces XP practices through hands-on exercises: Planning Game: User Stories, On-Site Customer Programming Game: Test-First Programming, Unit Testing, Pair Programming Refactoring Game: Code Smells, Once-and-Only-Once, Refactoring The exercises are paper-based and use a fireworks factory as their domain. Student volunteers help play the part of the customer and the unit testing framework. As a participant, you will help create a live simulation of several key practices of Extreme Programming. Attendee Background: Some familiarity with object-oriented concepts is helpful; no prior experience with XP is needed. Presenters: William Wake is interested in XP, patterns, human-computer interaction, and information retrieval. He is the author of Extreme Programming Explored and the inventor of the Test-First Stoplight and the XP Programmer’s Cube. Steve Metsker is a researcher and author who explores and writes about ways to expand the abilities of developers. Steve’s articles have explained how to maintain relational integrity in object models, how to solve logic puzzles in Java, and how the concept of “object” differs between Plato and the OO languages. Steve’s most recent publication is the book, Building Parsers with Java.

When people view the J2EE (Java 2 Platform, Enterprise Edition) specifications, too often all they see is a “bag of APIs” without a way to understand how the specifications work together in an application server. In this tutorial we will examine some template architectures for successful J2EE systems and show how a common set of design patterns can be applied to help designers navigate through the J2EE problem space. We will examine common client-side pitfalls and discuss the pros and cons of different design options, discuss how Java Servlets and JavaServerPages (JSPs) can work with and within technologies like Apache Struts, XML, and Extensible Style Sheets (XSL), and discuss how EJB (Enterprise JavaBean) systems can be structured to maximize component reuse while reducing wasted programmer effort. Attendee Background: This tutorial is targeted to Java programmers and designers, with at least some exposure to J2EE technologies (a reading knowledge of the J2EE specification and the associated API specifications will be sufficient). Programmers who have had experience with one or more of the J2EE technologies will gain the most from this review of how all the technologies fit together and how problems are solved using the entire J2EE framework. Presenter: Kyle Brown is an Executive Java Architect with IBM’s WebSphere Services unit. He is an experienced presenter at OOPSLA and other industry conferences. He has over twelve years of experience with object-oriented systems, and has been specializing in Enterprise Java systems since 1997. He is a co-author of The Design Patterns Smalltalk Companion and Enterprise Java Programming with IBM WebSphere, both published by Addison Wesley Longman.