tutorials

sunday all day

1 The Rational Unified Process

Philippe Kruchten, Rational Software Corporation

Convention Centre
Burrard Rooms I & II

The Rational Unified Process is a complete software engineering process. It provides a disciplined approach to assigning tasks and responsibilities within a development organization. Its goal is to ensure the production of high-quality software, meeting the needs of its end-users, within a predictable schedule and budget. It is tailorable to a wide range of projects and organizations. The Rational Unified Process is a superset of the Rational Objectory Process which integrates best practices from many disciplines and sources. The original Objectory process, centered around the concept of use case and an object-oriented design method, was first integrated with the Rational Process to make it an iterative process, focused on software architecture and using the UML as the notation for the several models that are built during the development. Other practices have now been integrated to make this process span the full development life-cycle: requirements management, data engineering, testing, configuration and change management, UI design and component-based development.

The objectives of this tutorial are to introduce the Rational Unified Process, explain its architecture and representation, and show some of its benefits. Attendees will learn how to structure, organize and control their own iterative process, using concepts such as architecture, object technology, and use cases.

Attendee Background: Software development managers, software developers, process engineers; no special background or pre-requisite is necessary.

Philippe Kruchten is Director of Process Development at Rational Software Corporation. He has some 25 years of experience in development of large-scale software-intensive systems in the areas of telecommunication, defense, aerospace, transportation, and software development tools. Dr. Kruchten has presented tutorials during the last 10 years on a wide range of topics, from Ada, to software architecture, and now software development process.

2 Practical Use Case Modeling

Frank J. Armour, George Mason University and Granville Miller, Make Systems Inc.

Convention Centre
Ballroom A

This full day tutorial will present a practitioner's approach to developing use cases. The tutorial will first present the basic concepts and approaches involved in use case modeling. The tutorial will then touch on advanced topics including: how to organize a large use case model, when and how to apply extends and adds relationships, how to model business processes, change cases, and use case frameworks. At the end of the day, the participant will have gained the basic knowledge necessary to create use cases in a project setting. Practical examples will be used to demonstrate the concepts and methods presented in lecture. The step-by-step approach takes a case study from the definition of the high level use cases to an expanded, elaborated use case model.

Attendee Background: The intended audience for the tutorial is business analysts, project leaders, developers, customers, and users involved or who have a stake in the use case modeling process.

Frank Armour is currently an Associate Research Professor at George Mason University in the Department of Information Systems and Software Engineering. His interests include use case modeling, requirements engineering, systems architecture, and object-oriented development. At George Mason University, Frank teaches courses on Requirements Engineering, Object Oriented Design and Software Systems Engineering.

Granville Miller is currently the Manager of the Framework Development Team at Make Systems. His interests include the software development process, use cases, framework development, and metrics. Mr. Miller has extensive experience in developing products and frameworks in telecommunications systems. He was part of the original team of developers responsible for IBM's VisualAge product, has written several papers on OOT, and presented tutorials and co-chaired workshops at several OO conferences.

3 Lo-Fi Design Strategies for Creating Highly Usable Object-Oriented User Interfaces

Luke Hohmann, SmartPatents, Inc.

Convention Centre
Room 10

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. In other words, just because you have captured the underlying objects of a problem domain does not mean the system will be successful You must still design a user interface that is effective, appealing, intuitive, and easy to learn. In short, 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. Once complete, participants will learn how to validate the effectiveness of their user interfaces. In summary, 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;
implement lo-fi prototypes in a manner that is consistent with the underlying domain model.

Participants will receive a draft copy of the forthcoming book on this topic, as well as a pre-made "GUI Design Kit."

Attendee Background: Participants should have a basic knowledge of object-oriented analysis and design, use cases, and scenarios. Participants should 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.

Luke Hohmann is Vice President of Engineering at SmartPatents, Inc. Author of "Journey of the Software Professional: A Sociology of Software Development" (Prentice Hall), he especially enjoys his mission of consulting, writing, and speaking about the sociology of software development. Mr. Hohmann is currently working on two books, "GUIs with Glue: Creating Usability Through Lo-Fi Design" and "Mastering Software Patterns in C++." Mr. Hohmann has a B.S.E. in Computer Engineering and an M.S.E. in Computer Science and Engineering from the University of Michigan.

4 Concepts of Object-Oriented Programming

Raimund K. Ege, Florida International University

Waterfront Centre Hotel
MacKenzie Room 2

The tutorial has two major parts. Part 1 discusses in detail all object-oriented concepts and uses Java to illustrate them. The focus is on a precise non-confusing definition of the core OO concepts and terminology; such as, object, instance, class, attribute, service, message passing, hierarchy, inheritance, polymorphism, late binding, memory management, access specification and packaging. Part 2 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. A small case study program will be solved in each language. There is also a discussion of whether and how each language supports advanced concepts, like multiple and repeated inheritance, genericity, interfaces, etc.

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, but a fundamental background in computer science and/or computer programming is.

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 several successful tutorials at major conferences including OOPSLA.

5 Pattern Writing

Frank Buschmann, Siemens AG; James Coplien, Lucent Technologies; Richard Gabriel, DreamSongs RPG, Inc.; and Christa Schwaninger, Siemens AG

Convention Centre
Room 12

Software patterns are a literary form, designed to communicate expert knowledge about system construction. The most useful patterns are the ones that address structural problems, and which are carefully written to be readable. This tutorial teaches pattern-writing skills in the context of the broader goals and values of the pattern community. A small amount of lecture is mixed with exercises and small work sessions. Participants do a comparative analysis of published patterns. In an associated follow-on workshop, participants work in small teams to write patterns, and to participate as an author in a writer's workshop.

This tutorial helps the attendee appreciate patterns as a literary form in the broader context of a pattern culture that has emerged over the past five years. Specifically, the attendees will learn: key aspects of the pattern value system, how to recognize traits of a well-written pattern, what to look for when reading and applying patterns, several popular pattern forms, pattern vocabulary, and the Writer's Workshop review format.

The tutorial will be followed by a highly interactive workshop (workshop 23) on Monday where participants apply the skills learned in the tutorial. The workshop will involve collaborative writing and personal consulting from the instructors. Each work will be reviewed in a writer's workshop format. See workshop 23 for more details.

Attendee Background: A basic software design background is helpful, but not necessary, to fully enjoy the workshop. We encourage attendance by individuals with diverse backgrounds, including (especially!) areas outside computer science.

Frank Buschmann is a co-author of "Patterns of Software Architecture" and is a software engineer at Siemens Corporate Technology in Munich. He has been involved in several concrete industrial software development projects.

Jim Coplien is a Distinguished Member of Technical Staff at Bell Laboratories in Naperville, Illinois. He is the author of the "Software Patterns" management briefing and co-editor of several pattern books.

Richard Gabriel is author of "Patterns of Software," and holds an MFA in Poetry from Warren Wilson College. He is well known in the pattern community for introducing the writers' workshop format for pattern review.

Christa Schwanninger is a software engineer at Siemens Corporate Technology in Munich where she works on distributed applications. She has done pioneering work in patterns for compiler construction and language design.

6 OMG's CORBA and Object Management Architecture

Jon Siegel and Nicole Glinski, Object Management Group

Convention Centre
Rooms 2 & 3

Written and maintained by the 800+ member companies of the Object Management Group (OMG), CORBA (Common Object Request Broker Architecture) is the open standard for distributed object computing. Products from multiple vendors implement CORBA in C, C++, Java, Smalltalk, COBOL, Ada, and other languages and environments; all interoperate freely based on the OMG-mandated protocol IIOP plus other protocols used in special situations. This tutorial begins with an overview of CORBA, explaining how the Object Request Broker and OMG/ISO Interface Definition Language combine to provide the basis for platform-independent interoperability. Mappings from IDL to various programming languages standardize access from each, and a multi-level network protocol specification allows out-of-the-box interoperability without restricting access to specialized protocols where needed. Finally, an examination of the high-level architecture provided by the CORBA services and facilities is provided.

Participants will learn: fundamentals of CORBA and the OMA, how to design applications for CORBA, basics of OMG/ISO IDL, what ORBs do, how CORBA provides system and vendor-independent interoperability, how to design for the rich set of CORBA services and facilities, about the many vertical markets that are standardizing CORBA objects.

Attendee Background: This tutorial is targeted at systems architects, software developers, and software engineers who design or write distributed applications, or who are selecting a distribution architecture for their enterprise or software company.

Dr. Jon Siegel, Director of Domain Technology, chairs the Domain Technology Committee responsible for OMG specifications in vertical markets including: Finance, Electronic Commerce, Healthcare, Telecommunications, Manufacturing, Transportation, and Business Objects. He is the author of publications, and principal author of the book, "CORBA Fundamentals and Programming." He was also the principal lecturer for the OMG-sponsored training session "CORBA Academy," and presents tutorials regularly. As a spokesperson for OMG, Siegel is a frequent speaker at conferences, meetings, and private corporate briefings in the United States and around the world.

Nicole Glinski is the Marketing Communications Specialist at Object Management Group, handling a variety of programs. She is responsible for the Speakers Bureau, in regards to finding and placing speakers, Tradeshows and Conferences for OMG. Nicole also manages the CORBA Success Story Program, the CORBA Academy training webpage and is involved with other OMG membership programs.

7 Efficient Implementation of Object-Oriented Programming Languages

Craig Chambers, University of Washington

Waterfront Centre Hotel
MacKenzie Room 1

How are object-oriented languages implemented? What features of object-oriented languages are expensive? What optimizations have been developed to make object-oriented languages more efficient? This tutorial addresses these questions. After identifying the main features of object-oriented languages that are difficult to implement efficiently, three classes of implementation techniques are presented. First, run-time system techniques such as virtual function dispatch tables and inline caches are described. Second, static intra- and interprocedural analyses are discussed. Third, ways in which dynamic execution profiles can be exploited to complement static analysis techniques are described. To assess the relative importance of the techniques, empirical measurements of the effectiveness of many of these techniques, as implemented in the Vortex optimizing compiler, are presented for large benchmarks written in Java, C++, Smalltalk, Modula-3, and Cecil.

Attendees will become familiar with the issues and state-of-the-art techniques for implementing object-oriented languages efficiently.

Attendee Background: Attendees should be familiar with the features of object-oriented languages and also with traditional compiler techniques such as procedure inlining and data flow analysis.

Craig Chambers has been researching object-oriented language design and implementation since 1987, with publications in OOPSLA, ECOOP, ISOTAS, PLDI, PEPM, and TOPLAS on the topic. He developed the first efficient implementation of the Self language, and he is the designer of the Cecil language and heads the Vortex optimizing compiler project. Chambers is currently an Associate Professor of Computer Science & Engineering at the University of Washington, and he is program chair of OOPSLA'98.

8 Using Subject-Oriented Programming to Overcome Common Problems in Object-Oriented Software Development and Evolution

Harold Ossher and Peri Tarr, IBM T.J. Watson Research Center

Waterfront Centre Hotel
Waterfront Ballroom B

Subject-oriented programming (SOP) is a practical approach to object-oriented programming-in-the-large. SOP addresses some well-known limitations of object-oriented development without forcing developers to adopt new languages or abandon the object-oriented paradigm. These limitations include weaknesses in: non-invasive system extension and evolution, large-scale reuse and integration, system decomposition; multi-team and decentralized development.

This tutorial will present the SOP approach and show developers how to use it, both conceptually and using tool support. It will include a set of exercises to be worked through by participants alone and interactively.

Participants will learn how to identify and address, using subject-oriented programming, some difficult and pervasive problems in their own object-oriented software development activities. They will also learn how to leverage subject-oriented programming to facilitate the use of design patterns, frameworks, and reusable components in software systems.

Attendee Background: Familiarity with object-oriented concepts, and at least some experience developing object-oriented applications, is required. Familiarity with subject-oriented programming is not required.

Harold Ossher co-invented subject-oriented programming in 1993. He manages a group that has built C++ support and prototype Smalltalk and Java support for subjects.

Peri Tarr joined IBM T.J. Watson Research Center in 1996. She has a strong background in software engineering and the application of subjects to it.

9 Responsibility-Driven Analysis

Rebecca Wirfs-Brock, Wirfs-Brock Associates and John Schwartz, GST Telecom

Waterfront Centre Hotel
Cheakamus Room

This tutorial tours the current state of the Responsibility-Driven Analysis Method. Responsibility-Driven Analysis is a method that focuses on behavioral aspects. This tutorial presents a process for analyzing a system and creating system requirements and various documents describing our software system. Our method extends the basic concept of a Use Case, as described in the Unified Modeling Language (UML) to include conversations that depict interactions between the system and actors and change cases that describe how we intend to change and extend existing systems. We also develop a variety of descriptions including system requirements, concept glossaries, user navigation maps, and Use Case Packages. We continue to add precision and improve our understanding of the system to be built throughout analysis.

Participants will gain an overview of our current analysis process, as well as the activities and artifacts of responsibility-driven analysis. They will be presented with guidelines and examples to illustrate key decisions and work products. They will see how Responsibility-Driven Analysis artifacts both extend and fit with UML artifacts through examining analysis models from actual applications to illustrate key points of our analysis process.

Attendee Background: Participants should be familiar with object concepts and looking for a practical analysis process that emphasizes traceability between requirements and system descriptions, behavioral system descriptions, producing a consistent vocabulary for both system description, and producing a conceptual object model.

Rebecca Wirfs-Brock is President of Wirfs-Brock Associates, a company devoted to enabling companies to effectively leverage object technology. She teaches about and develops systems using Responsibility-Driven Development techniques. She is a recognized author, teacher and speaker on object design and co-inventor of the Responsibility-Driven design method. Rebecca was the lead author of "Designing Object-Oriented Software", Prentice-Hall, 1990. She served as conference chair of OOPSLA '95. Currently, she is writing an object design book that focuses on practical techniques and guidelines.

John Schwartz is the Director of Software Architecture at GST Telecom. He is responsible for GST's distributed object model framework that integrates billing, provisioning, and customer care functionality. John was previously an instructor and consultant at ParcPlace-Digitalk, where he contributed to the Object Behavior Analysis (OBA) methodology. He has over 20 years experience in industry, including managing training and consulting groups, developing large information system applications, and contributing to OMG object database standards.

Another tutorial on the responsibility-driven approach is:

21, 21R: Responsibility-Driven Design

10 Techniques for Object-Oriented Analysis and Design

Martin Fowler, Independent Contractor

Convention Centre
Room 1

Over the last decade many trees have paid with their lives for writings on object-oriented analysis and design techniques. This tutorial is a grand tour of these techniques. Like many grand tours there is little time for details on the individual techniques. But there is time to give a flavor of what they are like, point out what they are good for, and to let you know where to find more. Many of these techniques (use cases, class diagrams, interaction diagrams) are present in the Unified Modeling Language (UML), but we'll also look at other important techniques (such as CRC cards, design by contract, and patterns) that will be useful.

If you are new to OO techniques this tutorial will give you an overview of what is out there and where to find out more, some breadth before you go into depth. If you are more experienced this tutorial will round out your experiences with a broader view of OO techniques. The tutorial also is an ideal introduction to the UML, pointing out its key techniques, but also some useful missing links.

Attendee Background: Attendees should know about the basic object-oriented principles. Knowledge of OO, or traditional methods, is useful but not essential.

Martin Fowler has spent over a decade to applying object technology to business information systems. He is an independent consultant who trains and mentors his clients in analysis and design techniques, project management, object-oriented programming, and the use of patterns. He is a popular speaker on the conference circuit and the author of "Analysis Patterns: Reusable Object Models" and "UML Distilled: Applying the Standard Object Modeling Language," which he likes to think is the world's smallest methodology book.

11 Exploring the Unified Modeling Language by Example

Charles Richter, Objective Engineering, Inc.

Convention Centre
Room 13

As the "unification" of the OMT and Booch notations, the Unified Modeling Language (UML) is emerging as the standard object-oriented analysis and design notation because it attempts to provide notation for most aspects of object-oriented design. However, UML is a rich and complex language. This tutorial uses the design of a small problem to explore many of UML's more advanced features, including use case diagrams, activity diagrams, and concurrency and distribution constructs.

Upon completion of this tutorial, attendees should have a deeper understanding of the UML and its application to real, everyday problems. Attendees will also be exposed to some of the more advanced and unusual features of the UML.

Attendee Background: This tutorial is aimed at developers who have at least a rudimentary knowledge of the Unified Modeling Language (UML) notation and are interested in a more detailed understanding of the application of that notation. The tutorial assumes the attendee understands basic object-oriented concepts such as classes, inheritance, and polymorphism, as well as the basic object-oriented modeling and design constructs such as class diagrams (object models) and object interaction diagrams.

Charles Richter has been involved in object-oriented development for over ten years, and has been teaching object-oriented methods for most of that time. He has considerable development and teaching experience with OMT, Booch, and more recently UML. He is the founder and a principal of Objective Engineering, Inc., a company dedicated to providing quality training and consulting in object-oriented analysis and design methods and Java programming.

12 Testing Object-Oriented Components

John McGregor, Clemson University and Software Architects, and Lee Copeland, Software Architects

Convention Centre
Room 16

This tutorial focuses on both techniques and a process for testing the individual components built as part of a project that uses object-oriented techniques. The tutorial is divided into two parts: (1) specific techniques and small examples to illustrate specific testing algorithms and (2) a process for component testing and a context of a complete testing process for object-oriented systems.

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 degree of coverage required by the 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. The three major benefits from this tutorial are: specific testing techniques, a comprehensive testing strategy that is integrated into the development process, and a specific infrastructure for building a reusable testing environment.

Attendee Background: Participants should have participated in the construction of object-oriented programs and performed some level of testing on these program. Component developers and technically-oriented system testers will benefit from this tutorial. Test managers and quality control personnel who are technically oriented will also benefit.

Dr. John D. McGregor is an Associate Professor of Computer Science at Clemson University and a senior partner in Software Architects, a software design consulting firm, specializing in object-oriented design techniques. Dr. McGregor has developed testing techniques for object-oriented software and custom testing processes for a variety of companies. He is co-author of "Object-Oriented Software Development: Engineering Software for Reuse," published by Van Nostrand Reinhold. Dr. McGregor is also co-author of "A Practical Guide to Testing Object-Oriented Software," to be published by Addison-Wesley. He has published numerous articles on testing including a monthly column on testing objects in the Journal of Object-Oriented Programming.

Lee Copeland has over twenty-five years experience as an information systems professional. He has held a number of technical and managerial positions with commercial and non-profit organizations in the areas of applications development and software development process improvement. He has taught seminars and consulted extensively throughout the U.S. and internationally. As manager of software development process improvement, he directed the design, introduction, and institutionalizing of formal procedures including static and dynamic testing. As project manager for a system using the object-oriented paradigm, he has focused on applying classical testing to OO systems and on understanding OO testing problems.

13 Modeling Component Architectures in Catalysis

Alan Cameron Wills, TriReme International Ltd

Convention Centre
Room 18

In component-based development, software products are assembled rapidly from robust (and more carefully designed) components that can be coupled in many configurations. Ideally, the components are designed as a coherent kit (like logic chips or Lego), from which many products can be made with minimum "glue." Larger components generally come from different sources and need "wrapping" to join a kit. Each component in a kit can plug into a wide variety of others. This is possible only if they have a common set of rules and protocols for their interconnections, and common models and representations of the domain concepts. These important definitions, the "component kit architecture," must be made at an early stage.

This tutorial will show how to use modeling techniques to define a kit architecture in detail, how to check the conformance of components to it, and how to reconcile the different models of bought-in components.

Attendee Background: This tutorial is intended for senior programmers, software architects, technical strategists, who wish to improve understanding of key issues in moving to a component-based architecture, either for a particular project, or as company strategy. Participants should have experience in OO programming, some UML; and some appreciation of the uses of postconditions.

Alan Cameron Wills has been a consultant and lecturer in object technology since 1990, working with clients in many fields including telecommunications and finance. He is the joint developer and a co-author, with Desmond D'Souza, of "Objects, Components and Frameworks with UML: the Catalysis Approach," Addison Wesley 1998.

Another tutorial on Catalysis is:

44: Catalysis: Systematic Components, Framework and Patterns with UML

14 Architecture for a Suite of Applications: Reuse for Business Success

Ivar Jacobson, Rational Software Corporation and Martin Griss, Hewlett-Packard Laboratories

Convention Centre
Rooms 8 & 15

Organizations who design and build highly technical systems, such as air traffic control systems, telecommunication systems or the complex financial applications used in banking and insurance systems, have a need to architect families of systems and reusable components. The architecture they create is pivotal to the success of the family. This tutorial, based upon the book, "Software Reuse: Architecture Process and Organization for Business Success," by Jacobson, Griss, and Jonsson, will address these architecting issues. The presenters will introduce and describe the higher-level architectural constructs now being accepted in the UML: systems of systems, subsystems, facades, frameworks, patterns, interfaces, and will relate them to use cases at different levels. They will also describe a systematic process that leads from the business processes of an enterprise, through the system architecture for a family of applications that support these business processes, to the architecture and design of the underlying reusable component systems.

Tutorial attendees will learn the importance of architecting in the development of a family of systems as well as the architectural constructs that are successfully being employed in the development of today's systems.

Attendee Background: The attendees should be experienced OO practitioners or software managers.

Ivar Jacobson is inventor of the Objectory Process, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community, well known for his pioneering work and more than 30 years experience using object methods for the design of large real-time systems. He is the principal author of three influential books, "Object-Oriented Software Engineering - a Use Case Driven Approach", "The Object Advantage: Business Process Reengineering Using Object Technology," and "Software Reuse: Architecture, Process and Organization for Business Success," as well as several widely referenced papers on object technology. His work on use-case engineering has influenced almost all of the OO methods in use today.

Martin L. Griss is a senior Laboratory Scientist at Hewlett-Packard Laboratories, Palo Alto, California, where for the last 15 years he has researched software engineering processes and systems, systematic software reuse, object-oriented development. He led HP efforts to standardize UML for the OMG. He was previously director of the Software Technology Laboratory at HP Laboratories, and an Associate Professor of Computer Science at the University of Utah. He is co-author of the book "Software Reuse: Architecture, Process and Organization for Business Success," writes numerous articles on software engineering and a column for the "Object Magazine," and lectures widely on systematic reuse and software process improvement.

15 Introduction to Concurrent Object-Oriented Programming in Java

David Holmes, Microsoft Research Institute, Macquarie University and Doug Lea, State University of New York

Waterfront Centre Hotel
Malaspina Room

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

David Holmes is a Ph.D. student with the Microsoft Research Institute at Macquarie University, Sydney, researching more adaptable, flexible, and reusable approaches to synchronisation in concurrent object-oriented programs. He has a degree in Computer Systems Engineering and practical experience with concurrent programming through work on operating systems, distributed systems and real-time embedded systems, within a university environment.

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.

16 An Introduction to the Java Foundation Classes (JFC)

Fintan Culwin, South Bank University

Pan Pacific Hotel
Pavilion A

The Abstract Windowing Toolkit (AWT) supplied with the initial releases of Java contained only a small number of user interface components which had a minimalist look and feel. The Java Foundation Class (JFC) toolkit, scheduled for release in the summer of 1998, addresses both of these limitations. This tutorial provides an introduction to the major components provided by the JFC in the context of the systematic design and development of artifacts which have a Graphical User Interface (GUI).

Attendees will receive an introduction to the importance of designing for usability from the outset of the developmental process, by means of State Transition Diagrams. They will also be introduced to the refinement of the usability design into presentational, behavioural and application concerns that will subsequently be implemented as distinct Java classes. This will be provided within the context of the JFC components and with regard to JavaBean requirements.

Attendee Background: Attendees will be expected to have existing intermediate knowledge of, and skills in, object-oriented software development, preferably including Java and UML notation. Knowledge of the Java AWT and event-listener mechanism would be advantageous but not essential.

Fintan Culwin is a reader in software engineering education at South Bank University, London, specializing in usability considerations and design notations. He is the author of books on Ada ('83 and '95), X/Motif, Java and Java/AWT. He has presented tutorials and papers on Java and interactivity on the Web at a number of international software conferences.

17 Introduction to Distributed Computing Using Objects

Eric Jul, DIKU, University of Copenhagen

Convention Centre
Room 11

As computer networks become faster and cheaper, it becomes more and more desirable to use distributed computing. Object-oriented programming seems to mesh exceptionally well with the paradigms of distributed programming because of object encapsulation and the clean interface presented by an object. The aim of this tutorial is to teach the basic ideas and paradigms of distributed object computing rather than a specific technology. As such this tutorial is a good lead-in for tutorials that address specific technologies. Issues covered include: communication, RPC, remote referencing, proxies, separation of concerns, interface and implementation, parallel processes, distributed, globally shared objects, distributed synchronization, reliability/failure handling, replicated objects, persistent objects, short overview of major implementation issues, short overview of available distributed object systems and languages, JAVA distribution issues, CORBA distribution issues, and WWW possibilities.

Attendee Background: The tutorial assumes basic knowledge of object-oriented concepts. No previous knowledge of distributed computing is required. Experience with one or more OO programming languages is helpful, but not essential.

Eric Jul is an Associate Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he heads the DistLab group, which is doing research in distributed, heterogeneous computing. He is a co-designer and principal implementer of the Emerald distributed object-oriented programming language developed at the University of Washington. His interests include distributed OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection), and object-oriented design and analysis. At previous ECOOP/OOPSLA conferences he has run a number of workshops and tutorials related to distributed computing. Dr. Jul is Program Chair for ECOOP'98.

18 An Introduction to Design Patterns

John Vlissides, IBM T.J. Watson Research Center

Waterfront Centre Hotel
Waterfront Ballroom C

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.

This tutorial is designed for software developers, including architects and programmers. Participants will acquire experience using design patterns to solve real problems. This experience will enhance participants' design abilities by teaching them how to apply design patterns to their own object-oriented systems.

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 or assumed. Familiarity with C++ is recommended.

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 has authored or co-authored several books, including "Design Patterns," "Pattern Hatching: Design Patterns Applied," "Object-Oriented Application Frameworks," and "Pattern Languages of Program Design 2," and he serves as Consulting Editor of Addison-Wesley's Software Patterns Series. He has published numerous technical papers and is a columnist for the "C++ Report." John has a Ph.D. in Electrical Engineering from Stanford University.

19 Surviving Your OO Project

Alistair Cockburn, Humans and Technology

Waterfront Centre Hotel
Waterfront Ballroom A

This tutorial presents over 60 strategies, truths, fixes, and recommendations to help keep your project and team alive through system delivery. It goes over success and failure stories that shed light on the lessons to be learned, then reviews, in sequence, steps that can be taken to reduce the project's risk. These include: reasons for selecting (or rejecting!) object technology in the first place, selecting the project, the project's goals, the team, the education, and the tools. A second round of lessons covers issues that arise in the first, second and third increments of a system's delivery, ways to tune the organization between increments. A third round covers trying to train large numbers of developers, and analyzes sentences you should never hear. A sample of project management patterns are reviewed at the end.

Attendees will first gain the understanding that their problems are not unique, but have been faced before, both successfully and unsuccessfully. They will receive specific, proven strategies to apply on their project, plus three proven project management patterns.

Attendee Background: The tutorial is targeted at managers and team leaders considering launching either a first or a larger project in object technology. Technical depth is not required, but will not pose an impediment. Any attendee is expected to have a decided interest in the decision factors that drive the project, the team, and the organization's growth.

Alistair Cockburn is a consulting fellow at Humans and Technology and special advisor to the Central Bank of Norway. He is a specialist in human factors in software development, particularly for object-oriented projects. Besides being an active software designer and project leader, he wrote OO methodologies for IBM in 1992, 1994, and 1996. His lectures and courses are requested throughout the world. Mr. Cockburn continually debriefs projects to learn more of what makes projects and teams work. His book, "Surviving Object-Oriented Projects" was published in 1997.

20 GOF Pursuit - Learning Patterns by Playing

Charles Weir and James Noble, Microsoft Research Institute, Macquarie University

Convention Centre
Room 19

Design patterns allow us to learn software design from the experience of others. Unfortunately patterns are difficult to learn using conventional techniques, so many designers have only a partial or incorrect understanding of the patterns available. This tutorial teaches GOF Pursuit, a game based loosely on "Trivial Pursuit." This game is effective in helping practitioners learn the patterns in the "Design Patterns" book. This tutorial will be a hands-on-workshop to help participants learn and re-learn patterns, to teach participants how to organise GOF Pursuit games, and to be fun at the same time.

This tutorial will enhance participants' design abilities by evaluating their knowledge of design patterns and by consolidating that knowledge, especially of the more complex patterns. Participants will use the techniques of the GOF Pursuit game to learn design patterns in breadth and depth.

Attendee Background: This tutorial targets anyone who is learning design patterns, who wishes to refine or improve their knowledge of design patterns, or who plans to introduce them to their workplace or teach them to others. It is assumed that the attendee is familiar with OO concepts, and has encountered the design patterns from the "Design Patterns" book.

Charles Weir has more than ten years of experience working on software development projects and has been using object-oriented techniques for more than six, providing on-site mentoring to many companies in Europe. Charles has presented sessions on patterns for clients and at conferences, and is the author of a chapter, "Patterns for Designing in Teams," in the recently published book "Pattern Languages of Programming 3."

Dr. James Noble is a Research Fellow in OO design at the Microsoft Research Institute, at Macquarie University, Sydney. He has researched, taught, and built OO systems for over a decade, has presented papers on design patterns in three continents. He has a Ph.D. in Computer Science from Victoria University of Wellington, New Zealand. He established the Sydney Patterns Group, the only patterns group in the Southern Hemisphere.

Another tutorial especially for educators is:

29: Using a Multi-Term Project to Teach OO Programming and Design

tutorials

sunday afternoon

21 Responsibility-Driven Design

Rebecca Wirfs-Brock and Alan McKean, Wirfs-Brock Associates

Waterfront Centre Hotel
MacKenzie Room 1

This tutorial tours the current state of the Responsibility-Driven Design Method. Responsibility-Driven Design is a design method that focuses on behavioral aspects. This tutorial presents a process for creating a design that satisfies system requirements. We use informal modeling techniques, such as CRC cards, object behavior stereotypes, and control style characterizations, to create an initial object model. We then continue to add precision and improve our design. Since system and application architecture, control style, abstraction levels, collaboration patterns and the application of key design patterns have significant impacts on design quality, these aspects are concentrated on in our presentation. Our process includes these activities: Exploratory Design, Adding Precision and improving a Design, Partitioning for Teamwork, and Designing for Change.

Participants will be given an overview of our current design process, a description of the activities and artifacts, guidelines and examples to illustrate key decisions and work products. The designs of actual applications will be used to illustrate key points of the entire process.

Attendee Background: Participants should be familiar with object design concepts and looking for a practical design process that emphasizes modeling techniques and description of the behavioral aspects of a software system.

Rebecca Wirfs-Brock is President of Wirfs-Brock Associates, a company devoted to enabling companies to effectively leverage object technology. She teaches about and develops systems using Responsibility-Driven Development techniques. She is a recognized author, teacher, and speaker on object design and co-inventor of the Responsibility-Driven design method. Rebecca was the lead author of "Designing Object-Oriented Software", Prentice-Hall, 1990. She served as conference chair of OOPSLA '95. Currently, she is writing an object design book that focuses on practical techniques and guidelines.

Alan McKean is Vice President and Director of Training 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 Buckminster Fuller and a graduate of the University of Oregon, he specializes in system architecture and design. He is currently collaborating with Rebecca Wirfs-Brock on a book on practical object design.

Another tutorial on the responsibility-driven approach is:

9, 9W: Responsibility-Driven Analysis

22 Mapping an Object-Oriented Design to an Object-Oriented Database

William Premerlani, General Electric Research & Development Center, and David Hentchel, Object Design Educational Services

Waterfront Centre Hotel
Cheakamus Room

An object-oriented design provides a solid basis for the implementation of an object-oriented database application. One of the biggest issues in implementing an object-oriented design concerns storing of objects for shared use. The persistence mechanism is extremely important to the eventual usefulness of most applications. An object-oriented database can solve the application's data storage requirements without sacrificing the benefits inherent in an object-oriented design. This tutorial uses ObjectStore, a commercial object-oriented database, to show how the object model and functional models of a database design can be implemented in practice. It briefly reviews UML notation, the Object Database Management Group persistence model, and ObjectStore features. It then explores design and implementation in detail. Examples are shown mainly using ObjectStore's C++ programming interface, with ObjectStore's Java interface briefly discussed.

Attendees will learn how to map an object-oriented design of a database application to an object-oriented database implementation, using ObjectStore as an example.

Attendee Background: Attendees should understand basic object-oriented concepts. Familiarity with UML and C++ is useful, but not required. Familiarity with ObjectStore is not required. Attendees should be interested in developing object-oriented database applications.

William Premerlani received his Ph.D. from Rensselaer Polytechnic Institute in Troy, New York, and is currently on the staff of the GE Research and Development Center. He is a coauthor of the OMT methodology and two popular text books, "Object-Oriented Modeling and Design," and "Object-Oriented Modeling and Design for Database Applications."

David Hentchel has M.A. degrees from the University of Missouri in Columbia, Missouri. He is the manager of education services for Object Design, responsible for development of object database training courses. Background includes over twenty years experience in the database industry, involved with database design, consulting and training for network, relational, and object databases.

23 Advanced Object-Oriented Concepts

James J. Odell, Consultant

Pan Pacific Hotel
Pavilion A

With so many OO analysis and design approaches, it is difficult to choose any particular approach. Furthermore, each approach has useful diagramatic elements that other do not. However, upon closer examination, most approaches are fundamentally the same. This tutorial begins by examining and formalizing the fundamental notions common to all OO approaches. With such a formal foundation in place, then, useful ways of extending this foundation are discussed at length--including the OMG's new UML standard for OO Analysis and Design.

The primary goals of this tutorial are:

to simplify the "jungle" of OO approaches by a basic foundation that applies to them all
to show how this foundation can be formalized in terms of relational and functional algebras, set theory, and predicate logic
to communicate the importance of know the difference between semantics and syntax
to demonstrate ways that this foundation can be used and extended--both now and in the future
to show how such foundations and their extensions will be vital in developing and using software products

Attendee Background: While this tutorial proceeds from first principles, it goes into depth at a fast pace. The audience should be experienced in using one or more OO analysis and design modeling techniques. The attendees that benefit the most are well-seasoned system modelers and meta-modelers with a background in mathematics.

James Odell is an IT consultant and practitioner specializing in the object-oriented approach. Throughout most of his 25 year career, he has been heavily involved in developing better methods to manage, understand, and express system requirements. He is the author of four books on OO and has also written numerous papers and articles on the subject. He is also the co-chair of the OMG's OO A&D Task Force.

24 Testing Object-Oriented Systems

John McGregor, Clemson University and Software Architects, and Melissa Major, Software Architects

Convention Centre
Room 19

This tutorial focuses on techniques and a process for testing a software application built as part of a project that uses object-oriented software development techniques. The 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. The three major benefits from this tutorial are: specific testing techniques, a comprehensive testing strategy that is integrated into the development process, and a specific infrastructure for building a reusable testing environment.

System testers and software developers interested in the complete product realization process will benefit from this tutorial. Test managers and quality control personnel who are technically oriented will also benefit.

Attendee Background: Participants should have participated in the specification and testing of complete applications that were constructed using object-oriented development techniques. This tutorial assumes experience on software development projects that use object-oriented development methods. It also assumes a typical system tester's knowledge of testing techniques. The examples in the tutorial are written in the use case notation and graphically represented in UML diagrams; however, the discussion of the testing approach provides sufficient context for experienced developers to understand the examples even if they do not read UML or have experience with the use case notation.

Dr. John D. McGregor is an Associate Professor of Computer Science at Clemson University and a senior partner in Software Architects, a software design consulting firm, specializing in object-oriented design techniques. Dr. McGregor has developed testing techniques for object-oriented software and custom testing processes for a variety of companies. He is co-author of "Object-Oriented Software Development: Engineering Software for Reuse" published by Van Nostrand Reinhold. Dr. McGregor is also co-author of "A Practical Guide to Testing Object-Oriented Software," to be published by Addison-Wesley. He has published numerous articles on testing including a monthly column on testing objects in the Journal of Object-Oriented Programming.

Melissa L. Major is a Consultant and Site Manager for Software Architects. She has worked for Microsoft, Broadway & Seymour, Computer Aid and BNR/NORTEL. She has a Masters in Computer Science and has been a Ph.D. student at Clemson University. Ms. Major has taught computer science courses for Clemson University and Limestone College. She has managed testing efforts and constructed software development processes including testing processes for companies such as Lucent Technologies. She has conducted an OOPSLA tutorial on testing object-oriented software and presented a technique for adapting the function point approach to object-oriented systems at OTC'96.

25 From C++ to Advanced Java in 1/2 day

Desmond D'Souza, ICON Computing

Convention Centre
Room 11

This tutorial will enable developers to make an effective transition from C++ to Java, within the framework of a solid object-oriented design paradigm. Covering key differences between the languages as well as between corresponding design approaches, it will illustrate these differences with a series of examples. Discussions and complete case study may be browsed at www.iconcomp.com.

Participants will: 1) understand language differences between Java and C++; 2) understand differences in design approaches in Java and C++; 3) learn Java as a language for very effectively building object systems; and 4) get an overview of Java libraries, current and future.

Attendee Background: Attendees must be familiar with C++ and object technology.

Desmond D'Souza is the President and CTO of ICON Computing, Inc. and a member of the faculty at the Software Quality Institute at the University of Texas at Austin. Mr. D'Souza publishes and speaks regularly at various object forums, and has used object technology since 1985. He is an author of the Catalysis method, writes the Modeling for Java column in the Journal of Object-Oriented Programming and in Report on Object Analysis and Design. He may be contacted at dsouza@iconcomp.com.

26 Distributed Java Applications

Michael Stal, Siemens AG

Waterfront Centre Hotel
Waterfront Ballroom C

Building distributed systems using Java is a complex task. First of all, there is a whole bunch of different technologies that might be used. Which one are we going to choose for a specific application context? Second, architectural issues must also be considered when developing distributed systems. Some low-level mechanisms such as sockets lead to systems that are very complex to understand, extend and maintain. The solution to this problem is the combination of distribution technologies and object-oriented programming. In this context, objects represent the units of distribution. Due to encapsulation and polymorphism distributed object models are possible that can be easily integrated into the object models of programming languages. Thus, mastering the complexity of distributed systems becomes easier and architectural drifts between different paradigms can be avoided. Standards such as Java RMI, OMG CORBA and Microsoft DCOM provide distributed object models on a wide range of different platforms. This is a major reason why most developers will inevitably need to understand the underlying concepts of distributing objects. Using Java helps to build distributed objects that are not bound to a single native system, but can be migrated to all machines where a Java Virtual Machine is running. Here, the benefits of distributed object computing and Java platform neutrality can be combined in previously unforeseen ways.

The goal of the tutorial is to introduce, classify, and compare different communication mechanisms applicable for building distributed systems using Java. Attendees will gain knowledge in fundamental concepts of distributed object computing as well as essential architectural aspects. The tutorial tries to prepare attendees with the knowledge to classify and evaluate these technologies and to choose among them.

Attendee Background: Participants should have a general familiarity with programming in Java. It is assumed that the audience is familiar with object-oriented concepts. Knowledge in distribution technologies is useful, but not required

Michael Stal is responsible for the research project Distributed Object Computing at Siemens AG. His main research areas are object-orientation, distribution, design patterns, and Java. He is co-author of the book "Pattern-Oriented Software Architecture - A System of Patterns," Wiley & Sons, 1996. He is also editor of Java Spektrum, a german SIGS magazine on Java. Michael is a member of the Object Management Group. He has many publications in object technology magazines, and has given talks and tutorials at many object technology conferences and forums.

27 Parallel Performance Patterns

Mathew Schemenaur, Perot Systems Corporation

Waterfront Centre Hotel
Malaspina Room

This tutorial presents a family of design patterns that improve software performance with an emphasis on parallel performance. These design patterns are categorized and presented using the UML notation. The parallel work patterns are organized into the following categories: Work Model, Eliminate Contention, Increase Parallel Section, and Resource Conservation. The essence of software design is making trade-off between competing objectives. Performance objectives are often at the center of this trade-off controversy. Designing a software unit for performance always adds complexity to the raw functionality. As a result, the performance objective is often competing with needs for design simplicity and flexibility. The consistent reuse of performance patterns will counter the added complexity. Consistency within a system will give the developer a sense of familiarity, even when examining unexplored software units.

Participants will acquire understanding of several advanced performance patterns. The experience will enable designers to clearly attack the performance objectives without loosing sight of the objectives for simplicity and flexibility. Participants can avoid re-inventing existing performance solutions and improve the clarity of their designs.

Attendee Background: The tutorial is aimed at software professionals wanting to learn design patterns that support performance issues. Participants should have knowledge of object-oriented principles and operating systems concepts like threads and concurrency.

Mathew Schemenaur has been designing object-oriented systems for over 10 years. During that time he has worked on several domain specific frameworks. For three years, he worked on a high performance object-oriented system for a major airline company. During this period, he used design patterns to capture and communicate patterns for parallel performance.

28 Object Transition Management

Kenneth Rubin, Secant Technologies, Inc.

Convention Centre
Room 13

Attempting to adopt object technology in an ad hoc manner is a prescription for failure. The successful introduction of object technology into an organization must be handled in a planned, incremental fashion. Transition management is a rigorous process for adopting object-oriented technology into an organization. The appropriate transition management strategy for one organization may not be suitable for another. This tutorial presents a methodology for developing a transition management strategy. Descriptions are provided of critical transition projects such as selecting a process model, establishing a reuse business model, defining team structures, establishing a training program, adopting a measurement strategy, and selecting development methodologies. Special emphasis is placed on the pitfalls that attend object transition strategies, and specific examples/recommendations based on the presenter's experience introducing object technology into many organizations are presented.

Participants will leave with a good foundation for developing their own transition management strategy.

Attendee Background: Participants should be preparing to introduce object technology into their organization, or in the process of adopting the technology. In addition, participants should be interested in the broad, interwoven set of managerial and organizational issues that influence a successful adoption of an advanced technology to meet business needs.

Mr. Rubin is Chief Operating Officer of Secant Technologies, Inc., a leading provider of enterprise object application server computing technologies for assembling, deploying and managing large, business-critical, distributed object systems. Mr. Rubin has over thirteen years experience working on and managing software development projects using object-oriented technology. He is the co-author, along with Adele Goldberg, of the book "Succeeding with Objects: Decision Frameworks for Project Management," and the author of over 30 publications on the topics of managing object-oriented projects, object-oriented analysis and design, artificial intelligence and human-computer interaction. Mr. Rubin received his BS. in Information and Computer Science from the Georgia Institute of Technology and his MS. in Computer Science from Stanford University.

29 Using a Multi-Term Project to Teach OO Programming and Design

James McKim, Jr., Rensselaer at Hartford

Convention Centre
Room 16

OO is touted as a software technology that promotes reuse, models the problem space, facilitates maintenance, incorporates changes easily, shortens the development lifecycle, encourages good software engineering techniques, and cures the common cold! Any course in Object Oriented Programming and Design should address these claims. One way (perhaps the only way) for students to test such claims and to gain appreciation of the paradigm's benefits and costs, is to participate in the building of a substantial product. This tutorial describes such a course and a project spread over several terms with ongoing enhancements and redesigns. An ongoing, multi-term project has the advantages of being more realistic, exposing students to issues at a depth that simply cannot be attained in a small project, and forcing students to absorb a sizable existing system (or at least some part of it) before they can make changes. The latter requirement is where students see the need for a modeling notation such as UML and for a common set of "tricks of the trade" as exemplified by design patterns.

This tutorial will discuss the positives and negatives of a multi-term project OO course as well as tips for teaching such a course.

Attendee Background: Participants should have a good grasp of the major features of the object oriented paradigm. This tutorial is aimed at people who have taught, or who are interested in teaching, accredited courses in OO programming and design. However, anyone interested in OO Education in any form may benefit.

James C. McKim, Jr. holds a B.A., M.S., Ph.D. in Mathematics from the University of Iowa, and an M.S. in Computer Science from Rensselaer, and is currently Professor of Computer Science at Rensselaer at Hartford. Dr. McKim has more than twenty years experience teaching mathematics and computer science. He has authored, and coauthored a number of textbooks and articles in both areas. He has been teaching, publishing, and consulting in the OO arena for the past seven years and has given numerous tutorials at OO conferences, including OOPSLA.

Another tutorial especially for educators is:

20: GOF Pursuit - Learning Patterns by Playing

30 Scripting: Higher-Level Programming for Component-Based Systems

Jean-Guy Schneider and Oscar Nierstrasz, Software Composition Group, University of Berne

Waterfront Centre Hotel
Waterfront Ballroom B

Complex software systems are increasingly required to be open, flexible conglomerations of software components. Components cannot be used in an arbitrary way, but according to architectural styles that determine how components are plugged together. System programming languages only offer limited support for gluing components in a flexible and extensible way and for explicitly representing higher level design elements in applications. Scripting languages, however, are designed for gluing: they are intended for adapting, configuring, and plugging together existing components, and achieve a higher level of programming than system programming languages. The use of scripting languages also encourages the development of reusable components (i.e., "bricks") highly focused on the solution of particular problems, and the assembly of these components with scripts (i.e., "glue").

This tutorial gives participants an overview of scripting, scripting languages, and scripting paradigms; demonstrates how scripting languages can be used to glue, adapt, and extend existing components; and illustrates the influence of scripting languages in the development of component-based frameworks and applications.

Attendee Background: Participants should have general knowledge in object-oriented concepts. Familiarity with a scripting language (e.g., Tcl/Tk, Python, Perl, Visual Basic) will be useful, but not required.

Jean-Guy Schneider works as a research assistant in the Software Composition Group at the Institute for Computer Science and Applied Mathematics of the University of Berne, Switzerland. His main interests are in object-oriented and parallel programming, scripting and glue languages, and the definition of formal methods for component-based software engineering

Oscar Nierstrasz is Professor of Computer Science at the Institute of Computer Science and Applied Mathematics of the University of Berne where he leads the Software Composition Group. He is interested in all aspects of component-oriented software technology, and particularly in the design and implementation of high-level specification languages and tools to support reusability and evolution of open applications.

32 Java, Eiffel and C++: the Language Comparison

Ian Joyner, Microsoft Research Institute, Macquarie University

Convention Centre
Room 18

This tutorial is based on an upcoming book comparing Eiffel, Java and C++. While the object models of these languages are very similar, they are very different in the ease with which software can be built. We will examine the differences between the languages, their strengths and weaknesses in a hard-headed look. The superficial syntactic differences will be looked at, but more importantly, the semantic differences and philosophical basis of each language.

We will see how these differences apply in actually developing software, as it is not just a question of theoretical niceness, but practical application, and what this means in terms of ensuring quality in software.

Attendee Background: This is aimed at an intermediate level of OO expertise for people with experience in any one or more of these languages. However, it will also be of interest to people who are considering which OO language to adopt.

Ian Joyner has been involved in object-oriented programming for almost 20 years, has developed many OO systems, notably communications programs and a music publisher in MacApp, and written OO compilers. He is also interested in programming language issues and is currently writing a book comparing Java, Eiffel and C++. He has ported EiffelS to the Macintosh, and has developed the MOTEL library. He is currently employed at Macquarie University in the Microsoft Research Institute where he is involved with project Bruce to translate Eiffel to Java, and interface the Eiffel and Java libraries.

34 Efficient Smalltalk Programming

Ken Auer, RoleModel Software, Inc.

Waterfront Centre Hotel
Waterfront Ballroom A

Smalltalk has been given a bad rap as a slow memory hog. But the reality is that there are many features of Smalltalk that can actually contribute to good performance and efficient use of memory. Smalltalk is like a power tool. And just as a power tool can create a lot of damage if used carelessly, Smalltalk can eat up CPU cycles and memory when used without the proper perspective and training. This tutorial will provide that perspective and training. The tutorial starts by illustrating the key contributors to the improper perspective and backs up the presenter's claims that Smalltalk can be made extremely efficient with simple case studies. It then presents an approach for identifying and fixing problems in Smalltalk programs. Techniques for solving individual classes of problems are discussed in detail with examples.

This tutorial is intended to give Smalltalk developers skills and confidence needed to address performance concerns they or their management might have.

Attendee Background: Participants should be literate in Smalltalk, preferably with 3+ months hands-on experience.

Ken Auer has been working with object technology since 1985, with a specialty in Smalltalk. Mr. Auer has been the chief architect for a number of successful frameworks and systems ranging from small prototypes to large distributed, multiple language systems and team sizes ranging from 1 to 150. He has particular expertise in creating efficient, high-quality, reusable components, frameworks, and architectures and is considered a master at maximizing system throughput. Mr. Auer has many published articles and book contributions (including "Lazy Optimization: Patterns for Efficient Smalltalk Programming" chapter of "Pattern Languages of Program Design 2," co-authored with Kent Beck). He founded RoleModel Software in 1997, after almost 9 years as a consultant with Knowledge Systems Corporation.

35 Software Architecture and the UML

Grady Booch and Philippe Kruchten, Rational Software Corporation

Waterfront Centre Hotel
Waterfront Ballroom C

The presence of a solid architectural vision is a key discriminator in the success or failure of a software project. This tutorial examines what software architecture is and what it is not, and presents a model for architectural representation using the UML. We also provide some case studies of software architectural styles, and include a discussion on how these architectures drive the development process. We conclude with a presentation of various architectural patterns using the UML.

This tutorial is intended to provide the attendees the skills to use the UML to represent the architecture of a software-intensive system and to express a variety of architectural patterns.

Attendee Background: A basic understanding of the UML is helpful but not essential. An understanding of the importance of architecture to the development process is helpful.

Grady Booch is Chief Scientist of Rational Software Corporation. He is a co-author of the UML.

Philippe Kruchten is Director of Process Development at Rational Software Corporation. He was also the architect for CAATS, Canada's air traffic control system. Dr. Philippe Kruchten is director of process development at Rational Software Corp. He has some 25 years of experience in development of large-scale software-intensive systems in the areas of telecommunication, defense, aerospace, transportation, and software development tools. He is currently in charge of the development of Objectory, Rational's software development process. Prior to Rational, he was with the European telecommunication manufacturer Alcatel, designing telecom switches. Dr. Kruchten has a diploma in mechanical engineering from the Ecole Centrale de Lyon (France), and a doctorate degree in computer science from the French Institute of Telecommunications, Paris (France).

36 Using Design Patterns and Frameworks to Develop Object-Oriented Communications Software

Douglas C. Schmidt, Washington University

Convention Centre
Room 11

Developing extensible communication software that effectively utilizes concurrency over high-speed, low-speed, and mobile networks is a complex task. This tutorial describes how to apply object-oriented (OO) design 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 Boeing, Ericsson, Lucent, Motorola, Siemens, and Sprint for telecommunication switch management applications, network management for large-scale global personal communication systems, electronic medical imaging systems, and real-time avionics.

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: object-oriented design techniques, object-oriented language features, tools, and advanced operating system mechanisms. The tutorial examines patterns and framework code abstracted from production systems in domains ranging from telecommunications, avionics, medical systems, Web servers, and real-time ORBs to illustrate key points.

Attendee Background: The tutorial is intended for software developers who are familiar with general object-oriented design and programming techniques, fundamental OO programming language features, basic systems programming concepts, and networking terminology.

Dr. Schmidt is an Associate Professor in the Department of Computer Science and in the Department of Radiology at Washington University in St. Louis, Missouri, USA. 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 systems on parallel processing platforms running over high-speed ATM networks. Dr. Schmidt is an internationally recognized expert on distributed object computing and has published widely in top IEEE, ACM, IFIP, and USENIX technical conferences and journals.

tutorials

monday morning

37 Creating a Paradigmatic Shift into the Object-Oriented Perspective

Alan Shalloway, Boeing and Net Objectives

Convention Centre
Room 13

Many companies are finding the transition to object-oriented development slowed by many developers' inability to shed their structured background. Developers with a structured background require a paradigmatic shift into the object-oriented perspective to speed up their effective use of this powerful technology. This tutorial takes a systems thinking approach, and contrasts structured and object-oriented methods to allow participants to view things from an object-oriented perspective and to permit further learning of OO methods without the hindrance of older (structured) methods. After this shift, additional object-oriented concepts are presented.

Participants in this introductory tutorial will understand the difference between the structured perspective and the object-oriented perspective. By contrasting these perspectives, the participant will be able to see possibilities in object-oriented design not available in structured programming.

Attendee Background: Participants should be familiar with software development, but need no experience in object-oriented development methods.

Alan Shalloway has been working with object-oriented technology since the early 1980s. Since that time, he has worked as both a consultant and a developer of vertical software in several industries. He is currently consulting with Boeing in assisting their transition to object-oriented technology. Alan's training method focuses on creating a paradigmatic shift to allow the participant a new way to view their current development challenges. Alan has found that using design patterns to illustrate basic object-oriented principles allows participants to grasp these concepts more quickly than standard training methods. His forthcoming book, "Using Design Patterns to Learn Object-Oriented Technology," should be published later this year. Alan has a Masters in Computer Science from the Massachusetts Institute of Technology.

38 Object Orientation and Fault Tolerant Systems

Jean-Charles Fabre, LAAS-CNRS

Convention Centre
Ballroom A

Fault tolerance is a crucial issue for the software industry in many application fields. This tutorial presents the role and the use of object-oriented concepts in the design and in the implementation of fault tolerant systems. Conversely fault tolerance techniques for object-oriented systems are discussed. Several approaches and object-oriented fault tolerant systems are analyzed including reflective and CORBA based architectures. Some real-time (timing faults) and security (intrusions) issues are also considered. Experiments on real prototypes are presented. Current limits, basic axioms for efficiency, as well as future research and development directions are discussed.

This tutorial provides to computer system designers architectural concepts for the development of fault tolerant object oriented systems. Participant will acquire key notions in fault tolerant computing and how to integrate them in object-oriented systems. They will understand the properties, the limits and the basic assumptions required for efficiency.

Attendee Background: No real background is required in fault tolerant computing, but some basic notions of object-oriented programming are necessary. Basic knowledge in operating system design is welcomed but not required.

Jean-Charles Fabre obtained his Ph.D. in Computer Science in 1982 and is a member of the "Dependable Computing and Fault Tolerance Research Group" at LAAS-CNRS in Toulouse-France. Working in fault tolerant computing for more than 15 years, he is now responsible for the research team on fault tolerant object-oriented distributed systems. He also led the development of the FRIENDS system, a reflective object-oriented fault tolerant architecture, and is a consultant for the aircraft and space industry. He teaches fault tolerant computing, security, distributed and object-oriented systems in several universities in France and abroad. He is author of more than forty publications and is co-author of two books on dependable computing.

39 Designing Concurrent Object-Oriented Programs in Java

David Holmes, Microsoft Research Institute, Macquarie University; and
Doug Lea, State University of New York

Waterfront Centre Hotel
Waterfront Ballroom A

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 behaviour. 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 that they have a good working knowledge of Java's concurrency mechanisms.

David Holmes is a Ph.D. student with the Microsoft Research Institute at Macquarie University, Sydney, researching more adaptable, flexible and re-usable approaches to synchronisation in concurrent object-oriented programs. He has a degree in Computer Systems Engineering and practical experience with concurrent programming through work on operating systems, distributed systems and real-time embedded systems, within a university environment.

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.

40 Java from UML

Stuart Kent, University of Brighton and Alan Cameron Wills, TriReme International Ltd.

Waterfront Centre Hotel
Malaspina Room

The promise of robust systems built rapidly from reusable distributed components is one of the attractions of Java. But developers are increasingly appreciating that clear and well-decoupled design is a prerequisite to that ambition. And to help understand their designs, developers are turning to modeling techniques, for which UML has become the standard. But UML is not just about presenting program code in pictures. At the whiteboard or in documents, it provides an unambiguous way to show the main ideas of your design, unobscured by fine detail. With UML you can write a precise description of your software's concepts, requirements, or high-level design - exposing them very clearly to critique and discussion. In component-based development, unambiguous description of interfaces is particularly important.

This tutorial will enable participants to: construct succinct but meaningful UML descriptions of Java components; understand what a model is and isn't promising about the software; systematically design Java to conform to these models; decide whether and how to use UML-to-Java code generator facilities.

Attendee Background: This tutorial targets software professionals wanting a clear language for discussing concepts and designs. Some experience in software development and object-oriented programming will be assumed. Acquaintance with Java will help.

Dr. Stuart Kent, University of Brighton, is a researcher, instructor and consultant in software development, visual modeling, OOD and CBD. He is a University Senior Lecturer in Computing, and a consultant and trainer to industry in the UK and US.

Dr. Alan Cameron Wills is a commercial consultant and trainer in OOD since 1991, working in a wide variety of application areas on both sides of the Atlantic. He is co-author of "Objects, Components and Frameworks with UML: the Catalysis Approach" (Addison Wesley 1998). Catalysis component-based methodology was developed from his thesis work, with Desmond D'Souza of Icon Computing Inc. They have also collaborated with Sterling Software's software solutions division, who have adopted it as their next-generation basis for teamworking tools and consultancy.

41 Beyond Objects: Unleashing the Power of Adaptive Agents

James J. Odell, Consultant and Roger M. Burkhart, John Deere

Pan Pacific Hotel
Pavilion A

This tutorial explores a future in which objects come alive as active and mobile agents inside the information networks of an enterprise. It proposes that we think beyond specific assigned roles of intelligent agents to think about entire systems of agents that adapt and evolve to meet larger goals. This tutorial surveys a wide range of agent-based systems, both natural and artificial, that are being studied within the emerging field of research known as Complex Adaptive Systems (CAS), and considers the lessons they offer for the engineering of autonomous object systems. These naturally decentralized systems offer an inherently parallel and scaleable approach to problem solving, along with a robustness of response to complex environments.

Participants will be encouraged to think about objects in entirely new ways, as active, autonomous elements that can integrate with the operation of a business.

Attendee Background: No specific requirements other than basic familiarity with object-oriented concepts, and a willingness to expand them.

James Odell is an IT consultant and practitioner specializing in the object-oriented approach. He was one of the early innovators of data and process modeling, and information engineering methodologies. He is the author of four books on OO and has also written numerous papers and articles on the subject. He is also the co-chair of the OMG's OO A&D Task Force.

Roger Burkhart is a developer and senior architect at John Deere in Moline, IL, where he explores the use of information technology in new business roles. Over the past four years he helped design and build the Swarm simulation system at the Santa Fe Institute. He has been involved in development of object tools since the mid-1980's, and is currently involved in the development of shared information networks for site-specific agriculture.

42 Advanced Object Project Management

Kenneth Rubin, Secant Technologies, Inc.

Convention Centre
Ballroom B

Software development projects have to be managed properly to obtain the most benefits from object-oriented technology. To meet and exceed project goals, issues surrounding planning and control, team structure, software development environment, methodology, reuse, quality assurance and measurement must be understood and addressed. This tutorial discusses advanced project management aspects related to these issues. The details of a particular shrink-wrapped, software development project will be used as a case study.

Participants will be acquainted with advanced project management issues surrounding software development projects using object technology through the presenter's sharing of real-world, detailed experiences in managing the development of a commercial software product. They will also be provided with useful suggestions and lessons learned.

Attendee Background: Attendees should be project managers or should have an interest in project management. Experience managing on one or more object projects would be helpful.

43 Objectory: The Unified Process

Ivar Jacobson, Rational Software Corporation

Convention Centre
Rooms 2 & 3

This tutorial introduces the Objectory process for component-based development. A better development process, in fact, a process unifying the best available practices, is the key to the software future. The proven Objectory process originally developed by Ivar Jacobson, now incorporating the work of Grady Booch, Jim Rumbaugh, Philippe Kruchten, Walker Royce, and other people inside Rational, answers this long-felt need. Component and object-based, Objectory enables reuse. Use-case driven, it closes the gap between what the user needs and what the developer does; it drives the development process. Architecture-centric, it guides the development process. Iterative and incremental, it manages risk. Represented in the design blueprints of the newly standardized Unified Modeling Language (UML), it communicates your results to a wide audience. Targeted at the basics, this introductory tutorial will bring you up to date.

Attendee Background: The attendees are expected to have experience in software development and some background in object technology.

Ivar Jacobson is inventor of the Objectory Process, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community, well known for his pioneering work and more than 30 years experience using object methods for the design of large real-time systems. He spent 25 years at Ericsson working on the AXE switching system, where he developed an architecture and a software engineering process to support extensive reuse. His early object-based design technique has evolved into the international CCITT/SDL Telecom standard. He is the principal author of three influential books, "Object-Oriented Software Engineering - a Use Case Driven Approach", "The Object Advantage: Business Process Reengineering Using Object Technology," and "Software Reuse: Architecture, Process and Organization for Business Success," as well as several widely referenced papers on object technology. His work on use-case engineering has influenced almost all of the OO methods in use today.

Another tutorial related to Objectory is:

1: The Rational Unified Process
2: Practical Use Case Modeling

44 Catalysis: Systematic Components, Framework and Patterns with UML

Desmond D'Souza, ICON Computing

Convention Centre
Room 19

Much of object-oriented design is about division of responsibilities and the specification of collaborations between objects, from the system/use-case level down to code. Frameworks are themselves compositions of partial collaborations, and using frameworks is greatly aided by a clear description of the underlying collaboration patterns. Serious modeling and composition of components and frameworks in the UML is not trivial. We describe a set of modeling tools with precise notions of interface, type, class, collaboration, role, frameworks, and composition, from the UML-based Catalysis method, and use these to capture key aspects of design patterns and frameworks in a way which is both abstract and precise. Catalysis combines strengths in requirements analysis and specification with a serious treatment of "pattern" composition, refinement, and architectural design. Its principal concepts have been contributed to UML 1.0 and 1.1 and standardized by the OMG. More detailed descriptions of these may be browsed at www.iconcomp.com/catalysis. This is not just a UML tutorial, since Catalysis goes beyond UML in the compositional modeling techniques it supports at model, specification, and design levels.

Participants in this tutorial will: learn systematic component and framework modeling; see how UML can support rigorous descriptions; understand modeling and applying patterns in UML.

Attendee Background: Attendees should be familiar with object modeling and programming, design patterns as defined by Gamma et al., and use-cases. Those using or intending to use patterns with UML or Fusion, seeking clearly defined semantics of models, composition, and refinement, and those looking for design methods suited for newer languages like Java, will benefit. Familiarity with OOP language features vs. abstract system models is a plus.

Another tutorial on Catalysis is:

13: Modeling Component Architectures in Catalysis

45 Business Modeling Using the Unified Modeling Language

Charles Richter, Objective Engineering, Inc.

Waterfront Centre Hotel
Waterfront Ballroom B

While the Unified Modeling Language (UML) is most often described as an object-oriented analysis and design notation, it also provides excellent features for business modeling. The use of a common notation such as UML for both the business model and the application design can promote synergy between the business and development views of the system. This tutorial uses a case study to illustrate how UML can be applied to describe both conceptual business models and the business processes that act on those models.

Attendees will gain an appreciation of how conceptual models can be cast as class diagrams, as well as how UML's use case and activity diagrams can describe business processes and workflows.

Attendee Background: This tutorial is aimed at business analysts and others interested in developing models of conceptual "business objects" and business processes. No knowledge of object-oriented concepts, conceptual modeling, or business process modeling is required.

46 Transparency in Distributed Object Systems: What, Why and How

Martin McClure, GemStone Systems, Inc.

Waterfront Centre Hotel
MacKenzie Room 2

Distributed systems have many advantages but are complex and can therefore be expensive to develop. Transparency in distributed object systems creates the illusion of a single object space, hiding much of the complexity of distributed computing from the programmer. This tutorial explains the basic mechanisms used to implement transparency and how to take advantage of them. It discusses the degree to which transparency is implemented in CORBA and various distributed object products, and includes ways to avoid potential pitfalls.

Participants will gain understanding of transparency and will learn to take advantage of its reductions in development cost and time while avoiding common difficulties

Attendee Background: This tutorial will require fluency in an object-oriented language. It is intended for those with an interest in distributed object systems, including developers and system architects who design or implement such systems. Previous exposure to some form of distributed object computing will be useful.

Martin McClure is a Senior Software Engineer at GemStone Systems, Inc. He has been an object-oriented developer, consultant, and architect for more than a decade, working on a wide variety of projects, large and small. His responsibilities have included implementation of transparency mechanism internals and use of others' transparent systems.

47 Patterns for Making your Business Objects Persistent in a Relational Database World

Joseph Yoder, University of Illinois

Waterfront Centre Hotel
MacKenzie Room 1

For developing simple client-server applications, VisualAge provides a visual language for generating the mappings of GUI's to database values and domain objects. For complex applications, tools such as TOPLink are very useful for simplifying the creation of persistent objects while hiding their implementation details. Quite often, application development requires tools for persistence that fall in between these two extremes. This presentation will describe how to make business objects persistent by mapping them to a relational database with minimal effort. It will also examine the patterns used to map domain-objects to a relational database.

Participants of this tutorial will learn a set of patterns and a language-independent object model that can be used for mapping business objects to a relational database. They will also learn how to develop a data access layer along with the design patterns used in the database tools provided by VisualAge and TOPLink.

Attendee Background: This tutorial is intended for those who are developing client/server applications and in need for an easy to use persistence manager that is powerful enough to store their domain objects into a relational database. It is also useful for those who want to understand the general principles of how persistent managers work. Basic knowledge of object concepts is required. A general understanding of relational databases and/or SQL is helpful though not necessary. Also, some understanding of patterns can be useful, but is not required.

Joe Yoder has over 10 years of professional programming, consulting, and teaching experience. His research interests include object-oriented languages and frameworks, as well as software reuse, software evolution, reflection, and patterns. Joe has developed frameworks, helped design several applications, and mentored many new developers. For the last two years Joe has been investigating "visual languages for business modeling". He is designing them, using them, and implementing them. Joe is also studying and writing design patterns for developing reusable software and domain specific languages.

48 Designing with Patterns

John Vlissides, IBM T.J. Watson Research Center

Convention Centre
Rooms 8 & 15

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.

This course is designed for software developers, including architects and programmers. Participants will acquire experience, using design patterns, to solve real problems. This experience will enhance participants' design abilities by teaching them how to apply design patterns to their own object-oriented systems.

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.

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 has authored or co-authored several books, including "Design Patterns," "Pattern Hatching: Design Patterns Applied," "Object-Oriented Application Frameworks," and "Pattern Languages of Program Design 2," and he serves as Consulting Editor of Addison-Wesley's Software Patterns Series. He has published numerous technical papers and is a columnist for the "C++ Report". John has a Ph.D. in Electrical Engineering from Stanford University.

49 Secrets of the Envy Masters

Alan Knight, The Object People

Waterfront Centre Hotel
Cheakamus Room

ENVY/Manager is the dominant team programming tool for Smalltalk. With its inclusion in VisualAge for Java, it is now gaining prominence in a wider arena. While it provides all the basics for productive team development, we wouldn't be Smalltalk developers if we didn't constantly extend and modify our tools. This tutorial provides a tour of ENVY internals. These are the secrets which ordinary developers don't need or want to know, but which are essential for the power users and tool builders. Concepts will be illustrated through concrete examples in both VisualWorks and VisualAge. This is not about using ENVY for project management or day-to-day development, except insofar as these motivate tool-building. It is about slides full of code and why you can't usefully inspect shadow metaclasses.

Participants will gain an understanding of mechanisms that can be used to extend the ENVY environment, and knowledge of many important details required to do so effectively.

Attendee Background: Participants should be experienced Smalltalk programmers who have used ENVY in a significant way.

Alan Knight is a regular columnist for "The Smalltalk Report" and reigning ENVY guru at The Object People. He has been programming in Smalltalk for over 10 years, and currently works on TOPLink, a framework for object-relational persistence. He enjoys drinking coffee, complaining about programming tools, and diving into undocumented mazes of hidden source code to fix them. He lives in Ottawa, Canada, and can be reached at knight@acm.org..

50 Typing in Object-Oriented Languages: Achieving Expressiveness and Safety

Kim Bruce, Williams College

Convention Centre
Room 18

Static typing aids in earlier error detection, supports compiler optimizations, and provides information to programmers on the intended use of constructs. However, simple static-typing disciplines for object-oriented languages like C++ and Java are so restrictive that programmers are forced to by-pass the type system with type casts. Other languages allow more freedom, but require run-time checking to pick up the type errors that their more permissive systems missed. After surveying problems with existing type systems (illustrated by a series of sample programs), we suggest ways of improving the expressiveness of these systems while retaining static type safety. Constructs introduced include "bounded polymorphism," "MyType," and "matching." We apply the concepts in the tutorial to compare the strengths and weaknesses of proposals to extend Java to support genericity based on F-bounded polymorphism, where clauses, match-bounded polymorphism, and virtual types.

Attendee Background: Attendees should be comfortable with the concepts of class-based object-oriented programming languages and have experience with static typing systems. The tutorial is aimed at programmers who would like the flexibility of weakly or dynamically typed languages, but the error detection and efficiency of statically-typed languages, as well as language designers and others who would like to see the applications of type theory to language design.

Kim Bruce is Wells Professor of Computer Science at Williams College in Massachusetts, USA. He received his B.A. from Pomona College and Ph.D. from the University of Wisconsin. He taught at Princeton University before coming to Williams. He has worked on the semantics of object-oriented languages for over 10 years, and provably-safe type systems for object-oriented languages for the last 7 years. He has presented papers at the ECOOP, OOPSLA, POPL, MFPS, and LICS conferences, and currently serves on the editorial board for TAPOS. He presented similar tutorials at OOPSLA'96 and at ECOOP'96 and '98.

51 Introduction to Visual Modeling and the UML

Terry Quatrani, Rational Software Corporation

Waterfront Centre Hotel
Waterfront Ballroom A

Modeling has been an essential part of engineering, art, and construction for centuries. Complex software designs that would be difficult for you to describe textually can readily be conveyed through design diagrams. Each diagram focuses on one aspect of your application. One may focus on structure, another on behavior, and yet another on the physical partitioning of your application. The model of your application may be used to verify its behavior with end-users. You can also use your model to clearly communicate with the members of your programming team. Modeling provides three key benefits: visualization, complexity management, and clear communication. UML stands for Unified Modeling Language. The UML is the standard language for visualizing, specifying, constructing, and documenting the artifacts of a software-intensive system. You can use the UML with all processes, throughout the development life cycle, and across different implementation technologies. Thus, the UML is the language of visual modeling.

This tutorial will provide the attendees an introduction to the UML, which may be used to visualize a software system.

Attendee Background: A basic understanding of software development using object oriented concepts is helpful but not essential.

Terry Quatrani is the Rose Evangelist for Rational Software Corporation and is responsible for successfully training and transitioning Fortune 500 customers (Xerox, Chemical Bank, NYNEX, Dun & Bradstreet, AT&T, CIGNA, Deutsche Bank, Lehman Brothers) to object technology. She is one of the top instructors at Rational Software Corporation. She is author of a number of OO courses including Object-Oriented Analysis and Design and Using Rational Rose. In addition, she is the co-author of the book, "Succeeding with the Booch and OMT Methods," and the author of the best selling book "Visual Modeling with Rational Rose and the UML."

52 Java Beans: Specifications, Design and Test

Desmond D'Souza, ICON Computing

Convention Centre
Ballroom A

Component standards like Java Beans promise standard reusable parts that can be easily composed. To be replaceable and scalable, the behavior of a Bean should be described in a way that is abstract (permit many implementations) and precise (clear, unambiguous, a basis for qualification and test). This tutorial will describe an approach to the precise and systematic specification of a Java Bean, extended to its design, implementation, and test.

Participants will: understand how component models extend standard object models; learn how to specify Java Beans precisely: methods, events, etc.; and see how precise specifications map to designs and tests.

Attendee Background: Attendees must be familiar with Java, and Java Beans basics.

53 A Practical Guide to Java on the Server

David Bailey, Hazim Kateeb, and Amy Weber, Advanced Computing Technical Services, Inc.

Convention Centre
Rooms 2 & 3

Java has primarily been used as a client development language because of its potential portability. A greater opportunity for the language, however, appears to exist in creating servers. While performance has kept many organizations from attempting to use Java to develop servers, recent advances in tools and compiler technology have opened the door to developing complex, information-intensive, and large-scale Java-based servers. This tutorial explores the practical use of Java on the server. It includes a brief overview of Java concepts, then describes typical architectures for Java-based servers. Optimization techniques, tips and traps, and development tools are discussed. A case study is used to solidify concepts and demonstrate the benefits of applying Java to servers.

Attendee Background: Attendees should have a working knowledge of OO concepts, software architecture, and Java.

David Bailey is President of ACTS, Inc., where he specializes in developing complex, large-scale, mission-critical applications for businesses. He has architected systems for diverse industries, such as telecommunications, transportation, distribution, and publishing. Mr. Bailey has taught advanced computing topics for several conferences and businesses in both the United States and Europe.

Hazim Kateeb is a developer for ACTS, Inc. Mr. Kateeb has developed several mission critical OO applications for the transportation and publishing industries. He is currently applying JAVA technology to web-based, distributed applications.

Amy Weber is Senior Designer/Developer at ACTS, Inc. Ms. Weber has several years of experience designing and developing large-scale object-oriented and component-based systems for the distribution, transportation, and publishing industries.

All of the speakers lecture at the Central Ohio Java Users' Group.

54 Patterns for Distributed and Agent-Based Systems

Craig Larman, ObjectSpace, Inc.

Convention Centre
Rooms 8 & 15

This tutorial presents a collection of practical patterns to develop distributed software architectures; these patterns range from the mundane to the sublime. However, they are unified by one common theme: it is not the functional requirements of the system that dominate distributed software design; it is instead the modal requirements, e.g., performance, reliability, scalability, security and cost-effectiveness. In addition, patterns to improve extensibility and reliability by using mobile agents are explored. On this tour, we introduce patterns for (1) brokered and peer server architectures, (2) agent subarchitectures, (3) server configuration, (4) common reliability problems, (5) common performance problems, and (6) visibility and access between server components. The tutorial provides an information-rich and panoramic glimpse inside the (slightly paranoid) world of distributed application design.

Craig Larman is the author of "Applying UML and Patterns - an Introduction to OOA&D," and Principal Instructor at ObjectSpace, which produces Voyager, an agent-enhanced object request broker. He also writes the "Modeling and Java" column in Java Report, and is the creator of the GRASP patterns for responsibility assignment. He has been using object technologies and assisting others on developing object systems since 1984. Craig's current focus is on helping developers efficiently learn to apply design patterns and principles for distributed and non-distributed systems development, especially those implemented in Java. Craig holds a B.Sc. and M.Sc. in Computer Science.

55 The Manager's Role in a Successful Transition to Object-Orientation

Normal Kerth, Elite Systems

Convention Centre
Room 13

Object-oriented thinking is just the latest of many technologies promising to improve software development. We hear claims such as increased productivity, higher quality, extendibility, reuse and portability. Whether these claims remain as dreams or are actually realized is dependent on the manager's ability to guide their organization to new, effective uses of this technology. The pressure to participate in the internet, as soon as possible, only adds to the importance of the manager's role. This highly acclaimed tutorial discusses what managers should expect and need to do as their organization grows in its maturity to use objects. It is a course loaded with a great deal of wisdom and experience. To realize these benefits and avoid the pit falls it is not good enough to simply let a few engineers use an object-oriented language. There is a great deal that needs to be managed, controlled and nurtured. In this tutorial, you learn how to develop a program that allows you to manage the introduction of this new technology into your projects.

This tutorial explores how managers can assure that their group makes a successful transition to using object-oriented technologies. It explores the appropriate deployment of the technology as well as the management issues that must be attended to. The tutorial takes the view that the transition is a long term project and discusses a manager's role over a many year period. It pays special attention to the process by which people work through a paradigm shift.

Attendee Background: No specific background required.

Norm Kerth is a consultant working with companies interested in ensuring that they make a successful transition to using the object-technologies. He includes the wider issues of specification and design activities, quality assurance, continuous process improvement, project management and building effective teams. Prior to starting his company, Elite Systems, he was a professor and researcher at the University of Portland. He has a decade of engineering experience with Tektronix and is a master teacher, with over 25 years of experience in front of students and computer professionals. He has been a frequent participant at OOPSLA since 1987.

56 Structuring Object-Oriented Software Development Project Teams in Support of System Architectures

Luke Hohmann, SmartPatents, Inc.

Waterfront Centre Hotel
Cheakamus Room

Conway's law tells us that the structure of the system is strongly influenced by the organizational structure of the team that builds it. Proper partitioning of object-oriented systems dictates a well thought out distribution of responsibilities among subsystems. Unfortunately, traditional approaches to team structure do not effectively support the adoption or use of object technology, for they do not adequately address the unique features of well-designed object-oriented system architectures. Upon attending this tutorial, the participant will be able to: describe architectures for object-oriented applications; define how to control growth within teams; define organizational structures and their usefulness in object-oriented projects; design organizational structures that support object-oriented development; determine if mentors or consultants are appropriate for their project; establish roles and responsibilities among team members.

Attendee Background: This tutorial is designed for those individuals responsible for managing an object-oriented project. A participant should understand basic concepts of object technology (e.g., class vs. instance, polymorphism, encapsulation). Prior project management experience is helpful, but not required. Because organizing a team is based on numerous soft and hard factors, participants should also bring an open mind, a willingness to share their successes and failures, and a desire to try something new.

Luke Hohmann is Vice President of Engineering at SmartPatents, Inc. Mr. Hohmann has extensive experience in object-oriented analysis and design, software engineering, user interface design, and project management. He is the author of "Journey of the Software Professional: A Sociology of Software Development" (Prentice Hall). Mr. Hohmann is currently working on two books, "GUIs with Glue: Creating Usability Through Lo-Fi Design" and "Mastering Software Patterns in C++". Mr. Hohmann has a B.S.E. in Computer Engineering and an M.S.E. in Computer Science and Engineering from the University of Michigan.

57 Business Engineering Using UML: The Object Advantage at Age Four

Ivar Jacobson, Rational Software Corporation; and Sten Jacobson and Gunnar Magnusson, Rational Software Scandinavia

Waterfront Centre Hotel
MacKenzie Room 2

Information technology people employ the modeling constructs of the Unified Modeling Language to model the software. What is less widely understood is that business people can employ UML to model new or revised business processes, incorporating their key values and strategies. Drawing on this model then, the information technology people can better focus the requirements for the software systems that will support the business concept. Moreover, since both sets of models employ the standardized models of the UML, the business attains results quickly and reliably. In addition to introducing the fundamentals of bridging business engineering to software development, the presenters will share the experience they have amassed since Jacobson's book, "The Object Advantage" was published in 1994. They will present three case studies. Attendees will learn to model business processes in UML.

Attendee background: This tutorial is targeted at software developers interested in finding the real requirements on their systems as well as business developers needing to describe a process-oriented business.

Sten Jacobson has more than 15 years of experience in the development of HW and SW for large telecommunication systems, and has been working with object technology since 1988. He is a frequent speaker at OO conferences and exhibitions throughout Europe and North America and also gives management seminars in the field of object-oriented business and software engineering. He has co-authored a series of columns, with Dr. Ivar Jacobson, on topics related to reuse and object-oriented business and software engineering processes.

Gunnar Magnusson has been working in the software tools industry since 1978 and joined Rational in 1991 (then Objectory AB) to manage the development of the Objectory software engineering products. Since 1994 he has divided his time between the development of Rational's business engineering products, based on "The Object Advantage," and the mentoring of several organizations applying these techniques and giving tutorials and seminars. He is also a co-author of the planned 2nd edition of "The Object Advantage."

Another tutorial on business modeling is:

45: Business Modeling Using the Unified Modeling Language

58 Designing A Light Methodology

Alistair Cockburn, Humans and Technology

Waterfront Centre Hotel
Malaspina Room

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. The first part of the tutorial introduces language and constructs needed to evaluate, compare, and construct methodologies. These include precision, accuracy, tolerance, relevance, and scale, along with the nine structural elements of a methodology. Several examples of effective, real, lightweight methodologies are given, along with commentary on the social setting for each. The tutorial then 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 lightweight and practical methodologies, optimized for productivity, and making maximum use of human, face-to-face communication. Considerations about success and failure in affecting culture are revisited.

Attendees will learn both what lies beneath and what constitutes the beast called "methodology." They will see why one size will not fit all, why book methodologies don't work as written, why home-grown methodologies seem to work, and what factors in their own organization affect their methodology. They will learn how to make greater use of the communicating and thinking abilities of the people on their team, and lighten up on the written deliverables.

Attendee Background: This tutorial is for experienced developers, team leaders, methodologists, and technology selectors trying to choose or design a methodology for their organization. Significant software team experience is expected, preferably but not necessarily OO. Participants must have used at least one methodology and thought about others.

Alistair Cockburn is consulting fellow at Humans and Technology and special advisor to the Central Bank of Norway. He is a specialist in human factors in software development, particularly for object-oriented projects. Besides being an active software designer and project leader, he wrote OO methodologies for IBM in 1992, 1994, and 1996. His lectures and courses are requested throughout the world. Mr. Cockburn continually debriefs projects to learn more of what makes projects and teams work. His book, "Surviving Object-Oriented Projects" was published in 1997.

59 A Third Generation OO Methodology - Advanced Tasks and Techniques

Richard Thomas, Queensland University of Technology

Convention Centre
Room 18

The increased complexity associated with large-scale systems requires an increase in the sophistication of the methodology used to manage these systems. OPEN (Object-oriented Process, Environment and Notation) is a third generation methodology that focuses not only on model building but also on project management, quality, reuse, and full and tailorable lifecycle support. Tasks and techniques within OPEN will be described in detail with emphasis on the more advanced contributions made by OPEN to the state-of-the-art in object technology.

This tutorial provides sufficient information for the methodology to be trialed in a business environment by the tutorial participants. The tutorial also provides a rationale why convergence of methodologies provides a more robust platform for the development of object oriented systems in an industrial context

Attendee Background: Project managers, systems developers, analysts and designers who are fully conversant with basic OO terminology and the need for a full lifecycle process methodology. Experience with OO methodologies would be advantageous.

Richard Thomas is a lecturer in software engineering in the School of Computing Science at the Queensland University of Technology (QUT). He is a member of the Centre for Object Technology Application and Research (COTAR), the premier object technology research centre in Australia. Richard is also a director of Thomaco Consultancies, a technology consultancy that specializes in software engineering and object technology. He has practiced object technology for a decade as a designer, implementer, researcher, lecturer and consultant.

60 101 Ways to Cook Corba

Annick Fron, Consultant

Waterfront Centre Hotel
Waterfront Ballroom B

CORBA is now a widespread technology. It has gained so many extensions that it becomes useful to tune its usage to best fit application-specific requirements. This tutorial will focus on applications and project requirements, looking at modeling and deployment aspects rather than raw technology, building on concrete experience and case studies in different vertical fields; such as, banking, telecommunications, etc.

Participants will get an overview of the different aspects to consider when tuning CORBA to a specific application, with examples in several vertical fields, including telecommunications and air traffic control. They will be given a number of caveats for migrating large applications. They will be provided an overview of existing techniques, strategies and products, a list of criteria for design and procurement decision, as well as useful pointers to answer their forthcoming questions.

Attendee Background: Attendees should be acquainted with CORBA and object-oriented concepts. This tutorial is targeted at software designers who have specific application needs and look towards CORBA solutions, and software engineers who want to gain insight into CORBA application domains and implementation strategy.

Annick Fron has been working with objects for more than 8 years, with degrees in Ecole Polytechnique from Paris and Ecole Nationale Superieure des Telecommunications. She is a free-lance consultant in object design and deployment for companies such as Societe Generale (France), Ascom (Switzerland), in many domain areas. She wrote a report on object components (CORBA, Active X) for the French Ministry of Research in 1996, and is teaching object components in several training sessions in France. For more see www.afceurope.com.

61 Introduction to OO Framework Development

Shai Ben-Yehuda, SELA Labs

Convention Centre
Ballroom B

Over the past decade, the object paradigm has shaped our thinking about reuse. A very effective form of reuse used in object-oriented technology is the object-oriented framework. In this tutorial we will try to understand what is a framework and how to construct our own framework. We will learn about concepts, architectural patterns, and methods that provide higher level of code reuse, design reuse, and enhanced development control in our development environment. The concepts, patterns, and methods covered in the tutorial are demonstrated with examples from MFC and Java standard libraries.

Participants will gain: a better understanding of frameworks and their role; principles, patterns, and tools that will help them to construct their own frameworks; and references in the framework field.

Attendee Background: The tutorial is targeted at software architects, team leaders, and technically savvy managers. Participants should be experienced in object-oriented design, and should have some knowledge in design patterns.

Shai Ben-Yehuda. M.Sc, works as an international lecturer, analyst, and consultant at SELA Labs, Israel. He has over eight years experience in object-oriented technology specializing in object-oriented analysis, software architecture, and organizational and human collaboration issues. Shai is the author of the Pattern Language for Framework Construction paper, which was presented and reviewed in PLoP 97.

62 The Standard C++ Library

Jan Christiaan van Winkel, AT Computing

Waterfront Centre Hotel
MacKenzie Room 1

The C++ language has lacked a standard library so far. Of course the iostream library has been there from the beginning, but a more fully equipped library has now been introduced in the ISO C++ standard. Some of the features of this new library (such as string classes and complex number classes) have been implemented by many programmers, but they are standardized now. Moreover, the new Standard Template Library (which is a part of the standard C++ library) will change the way programs in C++ are written. The Standard Template Library contains templates for algorithms, container classes, iterators, function objects and adaptors. STL is a major part of the tutorial. This tutorial will give an overview of the standard C++ library so you will know what to expect when it is available for your favorite C++ compiler.

Attendee Background: The attendees are expected to know C++. This tutorial will only discuss the "extras" of the standard.

JC van Winkel has a BS and a MS in computer science (the MS from the Vrije Universiteit Amsterdam). After working as a programmer/consultant for KPMG EDP Auditors for 6 years, he started at AT Computing in 1990. There he teaches UNIX and UNIX-related subjects, including C and C++. He co-authored the course notes for the C++ course. These course notes are published as a book by the Dutch publisher "academic service." J.C. van Winkel presented tutorials at OOPSLA`93, OOPSLA`94, OOPSLA`96 and OOPSLA`97. He is the Dutch representative in the ISO C++ standardization committee SC22/WG21.

Another tutorial related to C++ is:

32: Java, Eiffel and C++: the Language Comparison

63 Putting Metaclasses to Work

Ira Forman, IBM

Convention Centre
Room 19

The purpose of this tutorial is to demystify metaclasses and demonstrate how they can be used to increase productivity and reusability in object-oriented programming. The tutorial starts from first principles to construct an object model that is class-based (every object has a class) with first-class classes (every class is an object). After the object model is established, we introduce a metaobject protocol for manipulating the model. The metaobject protocol supports a new dimension for inheritance: inheritance of metaclass constraints. Based on this, we describe facilities required for composable metaclasses, that is, how a metaclass imparts to its instances the composite properties of its ancestor metaclasses. We conclude by demonstrating a number of useful metaclass that do compose with each other.

Attendee Background: The tutorial is intended for programmers who have a good understanding of object-oriented programming. Although the tutorial defines "class," "method," "inheritance," etc., the tutorial is definitely an advanced course and one has to know the basics. Just as one has to know about shapes and angles before taking high school geometry.

Dr. Ira R. Forman works for IBM in Austin. As a member of IBM's Object Technology Products Group, which has produced the SOMobjects Toolkit, he worked on the SOM Metaclass Framework. He started working in the area of object-oriented programming in 1984, when he worked at ITT Programming Technology Center. Forman received his Ph.D. in Computer Science from the University of Maryland, where he studied under Harlan Mills. Forman's specialties are object-oriented distributed systems and object composition.

64 Introduction to AntiPatterns

Thomas J. Mowbray, Blueprint Technologies, Inc.

Pan Pacific Hotel
Pavilion A

AntiPatterns are an intriguing new field of design patterns research and practice. AntiPatterns identify and categorize the common mistakes in software practice, a target-rich environment for AntiPatterns research. AntiPatterns also identify alternative solutions. Like Analysis Patterns, AntiPatterns extend the field of design patterns research into exciting new areas and issues, including: refactoring, reengineering, system extension, and system migration. This tutorial is based upon the new book "AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis" (John Wiley & Sons) co-authored by the tutorial presenter. AntiPatterns knowledge is based upon the 60 years of combined software project experience of the co-authors as well as numerous cited works, such as Dr. William Opdyke's thesis on refactoring, Bruce Webster's "Pitfalls of OO," Brooks' "Mythical Man-Month," and Yourdon's "Death March Projects." AntiPatterns are not new; they are commonplace in society, and they have been around since software's inception. "Spaghetti code" is an example. This tutorial transforms the study of AntiPatterns into a discipline with diverse practical applications. In particular, this tutorial shortens the learning-curve for attendees by presenting an AntiPatterns reference model and multiple AntiPattern examples, including case studies that document this exciting new field.

Participants will be able to recognize common AntiPatterns in software design, system architectures, and project organizations. They will learn how to refactor these AntiPatterns with a variety of alternative solutions and refactoring techniques

Attendee Background: This tutorial is for experienced software developers, architects, and managers. Multiple software project experiences are assumed but the tutorial does not assume a knowledge of design patterns nor object-orientation.

Thomas J. Mowbray, Ph.D. is Chief Scientist at Blueprint Technologies Inc. and the Chief Scientific Officer of OMG/Esprit COMPASS. He has 20 years software experience and holds a doctorate in Computer Science from USC, Masters in Computer Engineering from Stanford, and a BSEE from the University of Illinois. He is the co-author of four books covering distributed object architectures and a new book, "AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis." He is a Howard Hughes Doctoral Fellow, an Object Management Group Fellow, and Certified Human Potential Developer from the Esalen Institute Affiliate: People House. Dr. Mowbray writes regular columns for both "OBJECT Magazine" and "Distributed Computing Magazine."

65 Aspect-Oriented Programming Using AspectJ

Gregor Kiczales and Cristina Videira Lopes, Xerox Corporation

Convention Centre
Room 10

AspectJ is an aspect-oriented extension to Java that helps achieve improved separation of concerns in concurrent and/or distributed Java applications. AspectJ thus helps simplify code development and maintenance. AspectJ separates the implementation of functionality from issues of synchronization and distribution. In AspectJ there are three kinds of modules: (1) classes, which are used to implement system functionality; (2) coordinators, which are used to program control of thread synchronization; and (3) portals which are used to control data and computation movement in remote method invocations.

This tutorial shows how to program distributed applications using aspect-oriented programming and AspectJ. Additionally, we will present an overview of the implementation of AspectJ's weaver, with an eye to providing a general grounding in AOP.

Attendee Background: Participants should have experience with some object-oriented language, preferably Java, and be familiar with the basic issues in concurrent and distributed programming. Some knowledge of remote method invocation facilities is required. For the last part of the tutorial, as well as for the lab session, an advanced knowledge of Java and Java RMI is advantageous.

Dr. Cristina Videira Lopes is a scientist at the Xerox Palo Alto Research Center. Her research interests are in software engineering and programming languages. She has been developing aspect-oriented programming languages, in particular for distributed applications. She has co-organized several workshops in several conferences, namely the AOP workshops at ECOOP.

Gregor Kiczales is a principal scientist at the Xerox Palo Alto Research Center. His interests are in Software Engineering. His current projects include the development of aspect-oriented techniques for software engineering. He has served in several program committees for OOPSLA, ECOOP, ICSE, and others. He has been invited for keynote presentations in OOPSLA`94 and ECOOP`97. He is co-author of the book "The Art of the Metaobject Protocol."

tutorials

tuesday afternoon

66T

Testing Distributed Object Systems

John McGregor, Clemson University and Software Architects

Pan Pacific Hotel
Pavilion C

This tutorial focuses on techniques and a process for testing components built to be distributed across multiple processes. The tutorial will not be limited to a specific distribution architecture such as CORBA, but it will provide specific examples that use specific architectures. The tutorial is divided into two parts: (1) specific techniques and small examples to illustrate specific testing algorithms and (2) an architecture for developing the software needed for constructing test harnesses. The techniques presented in the tutorial are intended to provide variable levels of coverage and to allow the developer to focus on specific types of faults.

Component developers and technically-oriented system testers will benefit from this tutorial. Test managers and quality control personnel who are technically oriented will also benefit. The major benefits from this tutorial include specific testing techniques, and a specific infrastructure for building a reusable testing environment.

Attendee Background: Participants should have participated in the construction of distributed object-oriented programs and performed some level of testing on these programs. This tutorial assumes experience in the use of object-oriented development methods to build distributed systems. It also assumes a typical developer's knowledge of testing techniques. The examples used in the tutorial use C++/Java syntax; however, the discussion of the testing approach provides sufficient context for experienced developers to understand the example even if they do not read C++/Java.

Dr. John D. McGregor is an Associate Professor of Computer Science at Clemson University and a senior partner in Software Architects, a software design consulting firm, specializing in object-oriented design techniques. Dr. McGregor has developed testing techniques for object-oriented software and custom testing processes for a variety of companies. He is co-author of "Object-Oriented Software Development: Engineering Software for Reuse" published by Van Nostrand Reinhold. Dr. McGregor is also co-author of "A Practical Guide to Testing Object-Oriented Software," to be published by Addison-Wesley. He has published numerous articles on testing including a monthly column on testing objects in the Journal of Object-Oriented Programming.

67R

Patterns at Work

Frank Buschmann, Siemens AG

Pan Pacific Hotel
Governor General C/D

In this tutorial we present in detail part of a concrete real-world system and how it is designed with patterns: a flexible and extensible interface to an event-driven server application. Step by step we will re-play the process of its construction. We discuss the design problems that occur, present the patterns that could help solving these problems, discuss design alternatives, and show how we actually applied the patterns we selected. We will not only cover the successful aspects of the design, but also discuss dead ends we ran into, as well as wrong decisions we took. This will allow us to illustrate 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 we learned.

Attendee Background: Attendees should have sound knowledge in object technology and basic knowledge of patterns.

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. He is co-author of "Pattern-Oriented Software Architecture - A System of Patterns".

10R

Techniques for Object-Oriented Analysis and Design

Pan Pacific Hotel
Gazebo I/II

See description for tutorial 10.

for beginners (yellow):
Workshop 23: Pattern Writers' Workshop Tutorial 67R: Patterns at Work

for intermediates (green):
Tutorial 18: An Introduction to Design Patterns Tutorial 48: Designing with Patterns Tutorial 67R: Patterns at Work

for beginners (yellow):
Tutorial 17, 17T*: Introduction to Distributed Computing Using Objects

for intermediates (green):
Tutorial 26: Distributed Java Applications Tutorial 66T: Testing Distributed Object Systems

for beginners (yellow):
Tutorial 51*: Introduction to Visual Modeling and the UML Tutorial 35, 35W: Software Architecture and the UML

for beginners (yellow):
Tutorial 25: From C++ to Advanced Java in 1/2 day Tutorial 40: Java from UML Tutorial 53: A Practical Guide to Java on the Server Tutorial 15T: Introduction to Concurrent Object-Oriented Programming in Java

for intermediates (option 1- green):
Tutorial 26: Distributed Java Applications Tutorial 39: Designing Concurrent Object-Oriented Programs in Java Tutorial 52, 52T: Java Beans: Specifications, Design and Test Tutorial 53: A Practical Guide to Java on the Server

for intermediates (option 2- grey):
Tutorial 16: An Introduction to the Java Foundation Classes (JFC) Tutorial 26: Distributed Java Applications Tutorial 40: Java from UML Tutorial 52, 52T: Java Beans: Specifications, Design and Test Tutorial 53: A Practical Guide to Java on the Server

for intermediates (option 1- green):
Tutorial 15, 15T: Introduction to Concurrent Object-Oriented Programming in Java Tutorial 26: Distributed Java Applications Tutorial 39: Designing Concurrent Object-Oriented Programs in Java Tutorial 52, 52T: Java Beans: Specifications, Design and Test Tutorial 53: A Practical Guide to Java on the Server

for beginners (yellow):
Tutorial 6, 6R: OMG's CORBA and Object Management Architecture

for beginners (yellow):
Tutorial 5*: Pattern Writing Workshop 23: Pattern Writers' Workshop Tutorial 67R: Patterns at Work

for intermediates (green):
Tutorial 48: Designing with Patterns Tutorial 67R: Patterns at Work

for beginners (yellow):
Tutorial 40: Java from UML Tutorial 53: A Practical Guide to Java on the Server Tutorial 15T: Introduction to Concurrent Object-Oriented Programming in Java

for beginners (yellow):
Tutorial 11, 11T: Exploring the Unified Modeling Language by Example Tutorial 35, 35W: Software Architecture and the UML

The Rational Unified Process

Other tutorials on Objectory are:

Practical Use Case Modeling

Related tutorials are:

Lo-Fi Design Strategies for Creating Highly Usable Object-Oriented User Interfaces

Concepts of Object-Oriented Programming

Other tutorials on foundational OO topics are:

Pattern Writing

Other tutorials in the patterns thread are:

Related tutorials:

OMG's CORBA and Object Management Architecture

Other tutorials in the distributed object computing thread are:

Related tutorials:

Efficient Implementation of Object-Oriented Programming Languages

Other tutorials on advanced language-related topics are:

Using Subject-Oriented Programming to Overcome Common Problems in Object-Oriented Software Development and Evolution

Responsibility-Driven Analysis

Another tutorial on the responsibility-driven approach is:

Techniques for Object-Oriented Analysis and Design

Other tutorials on OO methodologies are:

Exploring the Unified Modeling Language by Example

Other tutorials in the UML thread are:

Related tutorials:

Testing Object-Oriented Components

Other tutorials in the testing thread are:

Modeling Component Architectures in Catalysis

Another tutorial on Catalysis is:

Other tutorials in the component-based development thread are:

Architecture for a Suite of Applications: Reuse for Business Success

Other tutorials on architecture are:

Introduction to Concurrent Object-Oriented Programming in Java

Suggested Readings:

Other tutorials in the Java thread are:

An Introduction to the Java Foundation Classes (JFC)

Other tutorials in the Java thread are:

Introduction to Distributed Computing Using Objects

Other tutorials in the distributed object computing thread are:

Related Tutorials:

An Introduction to Design Patterns

Other tutorials in the patterns thread are:

Related tutorials:

Surviving Your OO Project

Suggested Readings:

Other tutorials for managers are:

GOF Pursuit - Learning Patterns by Playing

Another tutorial especially for educators is:

Responsibility-Driven Design

Another tutorial on the responsibility-driven approach is:

Mapping an Object-Oriented Design to an Object-Oriented Database

Suggested Readings:

Advanced Object-Oriented Concepts

Other tutorials on OO methodologies are:

Testing Object-Oriented Systems

Other tutorials in the testing thread are:

From C++ to Advanced Java in 1/2 day

Other tutorials in the Java thread are:

Distributed Java Applications

Other tutorials in the Java thread are:

Other tutorials in the distributed object computing thread are:

Parallel Performance Patterns

Other tutorials in the patterns thread are:

Object Transition Management

Other tutorials for managers are:

Using a Multi-Term Project to Teach OO Programming and Design

Another tutorial especially for educators is:

Scripting: Higher-Level Programming for Component-Based Systems

Other tutorials in the component-based development thread are:

Model-View-Controller: Concepts and Implementations

Java, Eiffel and C++: the Language Comparison

Other tutorials on OO languages are:

Other tutorials in the Java thread are:

Analysis Patterns

Other tutorials in the patterns thread are:

Efficient Smalltalk Programming

Other Smalltalk tutorials are:

Software Architecture and the UML

Other tutorials on the topic of architecture are:

Other tutorials in the UML thread are:

Related tutorials:

Using Design Patterns and Frameworks to Develop Object-Oriented Communications Software