Sunday, 26 October

Monday, 27 October

Tuesday, 28 October

Wednesday, 29 October

Thursday, 30 October

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.

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

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.

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

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.

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.

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

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

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.

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.

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.

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.

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

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.

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.

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.

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.

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

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.

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.

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.

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.

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