*Funds to support student attendance of tutorials have been graciously provided by DaimlerChrysler and Microsoft Research.

Full-Day Tutorials, 8:30 - 5:00 (see schedule below)
1. Practical Software Measurement 2. Lessons Learned from Managing E-Business Projects 3. Documenting Software Architecture: Views and Beyond
4. Computing System Dependability 5. Goal-Oriented Requirements Engineering: From System Objectives to UML Models to Precise Software Specifications 6. Mastering Design Patterns
7. Value-Based Software Engineering 8. Usage-Centered Software Engineering 9. Internet Security
10. Pattern-Oriented Distributed System Architecture 11. Industrial-Strength Software Product-Line Engineering  

Half-Day Tutorials, 8:30 - 12:00 or 1:30 - 5:00 (see schedule below)
1. Feature-Oriented Programming for Product Lines 2. An Overview of UML 2.0 3. Best Practices for Implementing CMM-Based Software Process Improvement
4. Designing Software Architectures for Usability 5. Quality of Service Engineering With UML, CORBA, and .NET 6. Agile Unified Process

Full-Day Tutorial Schedule

Half-Day Tutorial Schedule, Morning Tutorials

Half-Day Tutorial Schedule, Afternoon Tutorials

Full-Day Tutorials

Sunday, May 4

Tutorial F1

Practical Software Measurement

This tutorial has been cancelled, we apologize for any inconvenience.

Tutorial F2

Lessons Learned from Managing E-Business Projects

This tutorial has been cancelled, we apologize for any inconvenience.

Tutorial F3

Documenting Software Architecture: Views and Beyond
Paul Clements, [contact], Senior Member of Technical Staff, Software Engineering Institute, USA; clements@sei.cmu.edu
David Garlan, Professor, School of Computer Science, Carnegie Melon University, USA; garlan@cs.cmu.edu
Reed Little, Senior Member of Technical Staff, Software Engineering Institute, USA; little@sei.cmu.edu
Robert Nord, Member of Techical Staff, Siemens Corporate Research, USA; rn@sei.cmu.edu
Judith Stafford, Professor, Tufts University, USA; jas@sei.cmu.edu

(Speaker biographies.)

A documented software architecture supports communication among system stakeholders such as managers, marketers, engineers, and maintainers. It serves as a base for education of members of the development team, system analysts, and newly hired developers, perhaps even new architects. It also serves as a base for early analysis of how well the system will fulfill behavioral and quality requirements. It is imperative to know how to write document an architecture so that interested parties can use it, maintain it, and build a system from it. Software projects increase the risk of failure to meet schedules, behavioral requirements, and/or quality goals without a blueprint that is clear, concise, and useful.

This full-day tutorial presents the "Views and Beyond" approach for software architecture documentation developed at the Software Engineering Institute. The approach is based on the simple principle that documenting an architecture is a matter of choosing and then documenting the relevant views of that architecture, and then documenting information that applies across all the views.

The primary aim of this tutorial is to teach software architects and developers how to write down a software architecture for a software system. Secondary aims include teaching what constitutes good documentation of a software architecture and why it is worth the effort to create and maintain architecture documentation.

This is a one-day tutorial scheduled for Sunday, May 4rth, 8:30 - 5:00.

Tutorial F4

Computing System Dependability
John Knight Professor, University of Virginia, USA; knight@cs.virginia.edu

(Speaker biography.)

Computer systems provide us with a wide range of services upon which we have come to depend. Many computers are embedded in more complex devices that we use such as automobiles, aircraft, appliances, and medical devices. Others are part of sophisticated systems that provide us with a variety of important facilities such as financial services, telecommunications, transportation systems, and energy production and distribution networks. Without these computer systems, many devices and services that are important either would not operate or would be much less useful. In some cases, the failure of a computer system can lead to extensive damage.

This is a full-day tutorial at the introductory level that will familiarize computer engineers, software engineers, managers, and researchers with the basic elements of the theory and practice of computing system dependability. The fundamental principles and basic concepts of dependability will be presented along with various dependability analysis techniques. Several practical techniques that help improve dependability will be introduced.

Fundamental topics covered will include the basic principles and definitions, types of fault, fault avoidance, fault elimination, and fault tolerance, system hazard analysis, event-tree analysis, failure modes and effects analysis, fault-tree analysis, software specification and verification, Byzantine agreement, fail-stop machines, real-time systems, and distributed systems.

Attendees will acquire a familiarity with the field so that they will be able to make appropriate choices in selecting techniques to apply within their own work and in their own future study. Attendees will be assumed to have a working knowledge of basic computer organization, programming in a high-level language, and the software development lifecycle.

This is a one-day tutorial scheduled for Sunday, May 4rth, 8:30 - 5:00.

Tutorial F5

Goal-Oriented Requirements Engineering: From System Objectives to UML Models to Precise Software Specifications
Axel van Lamsweerde Professor, University of Louvain, Belgium; avl@info.ucl.ac.be

(Speaker biography.)

Requirements engineering (RE) is the branch of systems engineering concerned with the elicitation of the objectives to be achieved by the system envisioned, the operationalization of such objectives into specifications of services and constraints, the assignment of responsibilities for the resulting requirements to agents such as humans, devices and software, and the evolution of such requirements over time and across system families. Getting adequate, consistent and complete requirements is difficult and critical. Recent surveys have confirmed the growing recognition of RE as an area of primary concern in software engineering research and practice.

This full-day tutorial first briefly introduces RE by defining its scope and the products and processes involved. A multi-view framework is then presented for system modeling in the specific context of engineering requirements. The framework integrates AND/OR goal diagrams for the refinement/abstraction of functional and non-functional objectives in the current system and in the system-to-be; UML class diagrams for modeling the conceptual objects concerned by such objectives; context diagrams for modeling agents in the system-to-be together with their responsibilities and interfaces; UML use case diagrams for modeling the software services that operationalize the functional goals assigned to software agents; and UML sequence and state diagrams for requirements mining and behavior modeling. Lightweight techniques for precise specification of the goals, objects, agents and operations from these various models are also discussed briefly. The next part of the tutorial is devoted to RE-specific model analysis; in particular, we review techniques for goal refinement, operationalization and assignment; analysis of obstacles to goal satisfaction for more robust system building; and management of conflicting goals among multiple viewpoints. The final part of the tutorial puts all previous pieces together by presenting a constructive method for elaborating a full, robust and consistent system model from which precise software specifications are derived. The presentation will strongly rely on running examples in two different domains: an information system and an embedded control system. The method and associated tool will be shown in action on a system simplified from a real project.

This full-day tutorial is aimed at both industrial and academic participants who wish to get a comprehensive overview of state-of-the-art techniques available in this critical area. No specific prerequisite is required. Tutorial attendants will get deep insights on the specific problems raised when engineering high-quality requirements, have a good sense of the range of current technical solutions to these problems, and increase their practical ability to build and analyze complex system models and software specifications.

This is a one-day tutorial scheduled for Sunday, May 4rth, 8:30 - 5:00.

Tutorial F6

Mastering Design Patterns
Craig Larman Chief Scientist, Valtech, USA; craig@craiglarman.com

(Speaker biography.)

During both initial software development and subsequent modification, a major cost that is often not appreciated is the quality of the design. These include the scalability, ease of comprehension, flexibility, and robustness in the face of change. Various studies indicate that after initial release, at least 50% of effort and cost is spent in modification. To save money, it is rational to take a long-term view of product development and invest in skillful designs that reduce these costs. This tutorial will provide designers with the skills needed to create high-quality object-oriented designs that support reduced modification costs and increased comprehensibility.

Design patterns are about the reuse of excellent, established design ideas, rather than code- best-practice formulas from experienced object-oriented developers. There are well-established, popular and useful design patterns, such as the "gang-of-four" (GoF) design patterns described in the hugely popular and influential book Design Patterns, the annual PLOP workshop patterns, and other sources, such as the Pattern-Oriented Software Architecture series. In this information-intensive tutorial, participants will learn how to apply the majority of high-frequency GoF design patterns

By attending this tutorial, you will learn to apply patterns for: varying algorithms, including Strategy; varying instance behavior, including Decorator; access control, including Façade and Singleton; organization of work, including Command; structural decomposition, including Composite; varying event response, including Observer; varying interfaces, including Adapter; varying instance creation, including Abstract Factory; varying implementations, including Bridge; and more, including coverage of idioms for package design.

This full-day tutorial is intended for object-oriented developers and architects with at least six months of object-oriented programming experience.

This is a one-day tutorial scheduled for Sunday, May 4rth, 8:30 - 5:00.

Monday, May 5

Tutorial F7

Value-Based Software Engineering
Barry Boehm, [contact], Professor, University of Southern California, USA; boehm@sunset.usc.edu
Kevin Sullivan, Professor, University of Virginia, USA; sullivan@cs.virginia.edu

(Speaker biographies.)

Attendees of this full-day tutorial will gain an appreciation for the increasing importance of value-based over value-neutral software engineering methods, an understanding of the major Value-Based Software Engineering (VBSE) concepts and techniques, and experience in applying the concepts and techniques to a representative software engineering case study. The tutorial is intended for software engineering practitioners and managers.

The tutorial will cover the following topics: participants' summary of their learning objectives (or value propositions) for the tutorial; an overview of VBSE techniques, and how they address current and emerging software engineering challenges, opportunities, and problems areas; a VBSE case study of a single-thread Internet-based order processing system; seven key elements of VBSE, including benefits realization analysis; stakeholders' value proposition elicitation and reconciliation; cost/benefit and business case analysis, continuous risk and opportunity management, concurrent software and system engineering, value-based monitoring and control, and change as opportunity. Additional topics include life cycle processes for implementing VBSE; a VBSE research roadmap and summary of recent research results; and a summary of emerging new research results which to exploit tools such as real options theory, portfolio theory, and statistical decision theory to understand the value provided by alternative software process and product decisions under conditions of uncertainty and change. These emerging methods can also help determine the value of buying information (via prototyping, benchmarking, COTS evaluation, architecture analysis, testing, etc.) to reduce risk in uncertain decision situations.

This is a one-day tutorial scheduled for Monday, May 5th, 8:30 - 5:00.

Tutorial F8

Usage-Centered Software Engineering
Larry Constantine, [contact], Director of Research and Development, Constantine and Lockwood, Ltd., USA; lconstantine@foruse.com
Lucy Lockwood, President, Constantine and Lockwood, Ltd., USA; llockwood@foruse.com

(Speaker biographies.)

Software engineering is often weakest when it comes to addressing the critical areas of user requirements, usability, user interfaces, and interaction design. Often these concerns are minimized, ignored, or relegated to other disciplines and other professionals as a responsibility outside the scope of software engineering. This tutorial for practicing software engineering, design, and development professionals and technically oriented managers shows how user requirements, usability, and user interface design can be made the very core of a successful software engineering process.

Usage-centered design is a systematic, model-driven approach to visual and interaction design with an established record of effectiveness over a wide range of project scopes within a wide variety of settings and areas of application. This full-day tutorial will introduce the models and methods of usage-centered design and explore the integration of usage-centered approaches into software engineering practice. Agile approaches to modeling will be stressed, with the focus on use cases, which are central to usage-centered design and serve as a common thread throughout an integrated usage-centered software engineering process. Although emphasis is placed on agile usage-centered, this approach also serves as an effective bridge to more elaborate structured forms of usage-centered modeling.

Usage-centered design is guided by three core models of users, tasks, and user interface contents. Users are modeled by the roles they play in relation to the planned system, tasks are modeled using a specialized form of use cases known variously as task cases or essential use cases, and interface contents are modeled in the form of abstract prototypes.

The emphasis in this tutorial is on practical application and skill-building. Participants will emerge with a broad understanding of usage-centered design and how it can be incorporated into the overall software engineering process. They will gain experience in modeling users, tasks, and user interfaces employing simplified agile modeling techniques to quickly organize information about users and user tasks into concise models for driving the design and constructing object-oriented software.

This is a one-day tutorial scheduled for Monday, May 5th, 8:30 - 5:00.

Tutorial F9

Internet Security

This tutorial has been cancelled, we apologize for any inconvenience.

Tutorial F10

Pattern-Oriented Distributed System Architecture
Doug Schmidt, Professor, Vanderbilt University, USA; schmidt@cse.wustl.edu

(Speaker biography.)

Developing software for distributed systems that effectively utilizes concurrency over high-speed, low-speed, and mobile networks is hard. This full-day tutorial describes how to apply architectural and design patterns together with middleware frameworks and components to alleviate the complexity of developing concurrrent distributed systems. These patterns, frameworks, and components have been used successfully by the speaker and others on actual distributed systems at hundreds of commercial companies in domains ranging from datacom and telecom, medical engineering, aerospace, defense, distributed interactive simulations, and financial services. The tutorial examines reusable solutions abstracted from production systems to illustrate the key technical design and implementation issues.

Attendees of this tutorial will learn, from examples, how to significantly simplify and enhance the development of middleware and application software that effectively utilizes concurrency and distribution via the use of advanced 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 infrastructure middleware (e.g., ACE and JVMs) and distribution middleware (e.g., J2EE, .NET, and CORBA ORBs); and advanced operating system mechanisms -- such as event demultiplexing, multi-threading, multi-processing, and explicit dynamic linking.

The material presented in this tutorial is based in part on the book "Pattern-Oriented Software Architecture: Patterns for Concurrent and Distributed Objects", Wiley & Sons, 2000, which is the second volume in the Pattern-Oriented Software Architecture (POSA) series co-authored by Frank Buschmann, Hans Rohnert, and Michael Stal.

This is a one-day tutorial scheduled for Monday, May 5th, 8:30 - 5:00.

Tutorial F11

Industrial-Strength Software Product-Line Engineering
John Klein, Chief Architect, Avaya CRM, USA; kleinjr@avaya.com
Barry Price, Consulting Member of Technical Staff, Avaya Labs, USA; rbprice@avaya.com
David Weiss, [contact], Director of Software Technology Research, Avaya Labs, USA; weiss@avaya.com

(Speaker biographies.)

Software product-line engineering is one of the few approaches to software engineering that shows promise of improving software productivity by factors of 5 to 10. However, there are still few examples of successful application of product-line engineering on a large scale partly because of the complexity of the problem of initiating a product-line engineering project and of the many factors that must be addressed for such a project to be successful. Practitioners and researchers alike are confronted with issues such as the following: How have others been able to succeed in creating and maintaining a software product-line? What approaches have been tried? How do I construct a convincing business case for product-line engineering? Whom do I have to convince? What are the key activities needed to start a product-line engineering project and to have it be successful? How do I recognize when my organization is ready to or needs to start product-line engineering? How do I measure the effectiveness of product-line engineering in my organization? How long will it take me to show some return? What does a product-line organization look like? How is it different from what my organization looks like now? What resources will I need? What training will my people need? This one-day tutorial draws on experiences in introducing and sustaining product-line engineering in Lucent Technologies and in Avaya to answer such questions.

Participants will gain an inside look at an organization that is transitioning into product-line engineering on a large scale. Success in such a project depends on both technical issues in creating and evolving a product-line, and organizational issues in transforming an organization to be compatible with the product-line engineering process. Participants will be shown by example what events and actions must take place at what times to be successful in introducing product-line engineering. We expect attendees to leave the tutorial with many ideas on how they can start introducing product line engineering into their organizations in a systematic way.

This is a one-day tutorial scheduled for Monday, May 5th, 8:30 - 5:00.

Half-Day Tutorials

Monday, May 5

Tutorial H1

Feature-Oriented Programming for Product Lines
Don Batory, Professor, University of Texas at Austin, USA; batory@cs.utexas.edu

(Speaker biography.)

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

GenVoca is a simple algebraic model of FOP that is based on step-wise refinement, a methodology for building programs by adding one feature at a time. The incremental units of implementation/design are refinements that encapsulate the implementation of an individual feature. GenVoca models of product-lines treat programs as values and refinements as functions (that map input programs to output programs with augmented features). Application designs are equations - compositions of functions and values - that are amenable to optimization and analysis.

FOP and Aspect Oriented Programming (AOP) are complementary, as both aspects and feature refinements encapsulate cross-cuts, i.e., fragments of multiple classes. The primary difference is emphasis: FOP follows a more traditional OO design approach to define cross-cuts, which focuses on how algorithms compose to build complete systems, rather than the AOP emphasis on join-points, point-cuts, and advice to modify existing programs.

This half-day tutorial focuses on AHEAD (Algebraic Hierarchical Equations for Application Design), the successor to GenVoca. AHEAD allows a single refinement to encapsulate simultaneous changes to multiple programs (e.g., tool suites like MS Office where individual features impact or cross-cut multiple tools) and changes to arbitrary program representations (e.g., makefiles, documents, code, etc.). Thus, by composing AHEAD refinements, consistent tool suites and their plethora of representations can be synthesized. AHEAD significantly broadens the capabilities of FOP and provides the basis for scaling system synthesis far beyond current technologies.

Attendees of this half-day tutorial will learn the basic concepts of FOP, models and tools for synthesizing a consistent set of code and non-code artifacts by composing refinements (cross-cuts), automatic algorithms for validating refinement compositions, synthesis of product-lines for product-families (e.g., tool suites), and automatic algorithms for optimizing application designs (equations).

This is a half-day tutorial scheduled for the morning of Monday, May 5th, 8:30 - 12:00.

Tutorial H2

An Overview of UML 2.0
Bran Selic, Principal Engineer; Rational Software Canada; Canada; bselic@rational.com

(Speaker biography.)

Since its adoption as an industry standard in 1997, the Unified Modeling Language (UML) has been adopted widely by both industry and academia. This extensive experience has naturally led to demands for improvements and new capabilities. In September 2000, the Object Management Group-the industrial consortium that controls the UML standard-issued a request for proposal for the first major revision of UML, UML 2.0. This new version was conceived as the basis for the coming generation of model-based development methods, such as OMG's Model-Driven Architecture (MDA). The distinguishing characteristic of these methods is that their primary focus is on the definition and evolution of models rather than programs-with programs being automatically generated from such models. The combination of higher-level abstractions defined in UML and the use of automation provide the potential for a dramatic improvement in productivity and software reliability.

Attendees of this half-day tutorial will learn the salient aspects of UML 2.0-from the perspective of one of its primary authors. The following specific topics will be covered: a general and critical discussion of the effectiveness of modeling techniques in software engineering; a critical review of the original UML standard based on the lessons learned from its application as well as from theoretical studies; the formal and informal requirements that drove development of the new version of UML (this includes an introduction to model-driven development methods); the overall structure and design philosophy behind UML 2.0; the conceptual foundation, or "infrastructure" used to define the UML modeling concepts and their semantics; new modeling capabilities for rendering software structures such as those required for specifying software architectures; new modeling capabilities for describing complex behavior of individual objects and groups of collaborating objects; changes to existing UML concepts; and the application of UML 2.0 in model-driven software development methods based on executable models and the use of automatic code generation Each of these concepts will be extensively illustrated with numerous practical examples.

This is a half-day tutorial scheduled for the morning of Monday, May 5th, 8:30 - 12:00.

Tutorial H3

Best Practices for Implementing CMM-Based Software Process Improvement
Bill Curtis, Co-Founder and Chief Scientist; TeraQuest; USA; curtis@teraquest.com

(Speaker biography.)

This half-day tutorial will provide an explanation of the principles underlying the CMM and CMMI, as well as guidance for choosing between them. The areas of focus in the tutorial include:

Participants in this tutorial will learn of the benefits that have been achieved and how they differ by maturity level; lessons learned and best practices for implementing process improvement programs; and observations on integrating process improvement programs with agile methods.

This is a half-day tutorial scheduled for the morning of Monday, May 5th, 8:30 - 12:00.

Tutorial H4

Designing Software Architectures for Usability
Jan Bosch, Professor, [contact], University of Groningen, The Netherlands; Jan.Bosch@cs.rug.nl
Natalia Juristo, Professor, Technical University of Madrid, Spain; natalia@fi.upm.es

(Speaker biographies.)

Usability is increasingly recognized as a quality attribute that one has to design for. The conventional alternative is to measure usability on a finished system and improve it. The disadvantage of this approach is, obviously, that the cost associated with implementing usability improvements in a fully implemented system are typically very high and prohibit improvements with architectural impact.

In this half-day tutorial, we present the insights gained, techniques developed and lessons learned in the EU-IST project STATUS (SofTware Architectures That supports USability). Attendees will learn about a forward-engineering perspective on usability, a technique for specifying usability requirements, a method for assessing software architectures for usability and, finally, techniques for improving software architectures for usability. The topics are extensively illustrated by examples and experiences from many industrial cases.

This is a half-day tutorial scheduled for the afternoon of Monday, May 5th, 1:30 - 5:00.

Tutorial H5

Quality of Service Engineering With UML, CORBA, and .NET

This tutorial has been cancelled, we apologize for any inconvenience.

Tutorial H6

Agile Unified Process
Craig Larman, Chief Scientist, Valtech, USA; craig@craiglarman.com

(Speaker biography.)

The Unified Process (UP) is popular-and with good reason, as it includes skillful practices such as iterative development, and early attention to risks. However, many organizations are adopting it in an unskilled manner, superimposing "waterfall" or "heavyweight" values onto it that need not apply. Applied well, the UP encourages an agile approach; furthermore, many XP and Scrum practices are either part of the UP, or specializations of more general UP guidelines.

In this half-day tutorial, you will learn why a combination of UP with other agile process practices is an excellent approach. Topics to be presented include: motivation and the business case for the UP; the key UP ideas to know and now to apply them; UP artifacts that are worth creating; UP anti-patterns (common worst-practices in adoption and use); how to adopt the UP within an organization; XP practices within the UP; challenges of pure UP; how to plan an iterative UP project; tips for good UP artifacts and models; UP models and the UML; how to define a UP development case; how to do architectural analysis and describe architectures in the UP; and how to fail with the UP (you know you didn't understand it when…)

Participant in this tutorial will learn the essential UP practices, the keys to successful introduction of the UP in an organization, and how to apply the UP in an adaptive and agile manner. And, how to screw it up.

This is a half-day tutorial scheduled for the afternoon of Monday, May 5th, 1:30 - 5:00.