This tutorial defines and teaches the basic object-oriented concepts, illustrates their advantages, and introduces the components and features of object-oriented programming languages and development environments. The tutorial enables an attendee to make an informed decision about what language / environment will best serve his/her software development needs. The tutorial has 2 major parts: Part 1 discusses in detail all object-oriented concepts. The focus will be on a precise, non-confusing definition of the core concepts and terminology. Part 1 uses Java as its sample language to illustrate the material. Part 2 then compares major object-oriented programming languages: C++, Smalltalk, Java, 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 will be used to illustrate the solution in each language. Presentation Format: Presentation. 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. Attendees should have a fundamental background in computer science and/or computer programming. Raimund K. Ege is an Associate Professor of Computer Science at 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. The tutorials were consistently rated highest and won praise from organizers and attendees.

Using only traditional techniques, the implementation of concerns like exception handling, multi-object protocols, execution tracing, and security policies tends to be spread out in the code. The lack of modularity for these concerns makes them difficult to develop and maintain. This tutorial will show how to use aspect-oriented programming to implement concerns like these in a concise modular way. We will discuss the effect aspects have on code modularity and on software design. The tutorial will work with AspectJ, a freely available aspect-oriented extension to the Java programming language. Participants will learn how to use aspect-oriented programming to solve real problems. After this tutorial, they will be able to apply aspects to their own object-oriented systems. Presentation Format: This tutorial will be 80% lecture and 20% design and coding exercises in groups. Attendee Background: Attendees should have object-oriented programming experience, and should be able to read Java syntax. Cristina Videira Lopes is a research scientist at the Xerox Palo Alto Research Center. Her research interests are in software engineering and programming languages. As a founding member of the AspectJ project, she is deeply involved in the design of the language and in the practical applications of AspectJ. She has been a co-organizer of several AOP-related workshops. For the last several years, she has been teaching novel programming techniques both for industry and academic audiences. She holds a Ph.D. in Computer Science and a BS and MS in Computer Engineering. Gregor Kiczales is a professor at the University of British Columbia, and a principal scientist at the Xerox Palo Alto Research Center. His research is centered around techniques that enable programs to as closely as possible look like the design they implement. He is the leader of the AspectJ project. He is a co-author of the book "The Art of the Metaobject Protocol." He has given invited talks at conferences such as OOPSLA, ECOOP, and ICSE.

This tutorial is for researchers and developers who want to use Java reliably, securely, and safely. This tutorial covers Java 2TM security, focusing on ClassLoaders, Class File Verifiers, SecurityManagers, and cryptography. Concepts such as ProtectionDomains, Policy, and privileged code will be explained in detail. The tutorial will also cover Java bytecode reverse engineering. Examples and scenarios will provide concrete examples of the technologies involved. This tutorial is based on Mr. Pistoia's latest book, "Java 2 Network Security," published by Prentice Hall PTR. Presentation Format: Presentation based, with code samples. Attendee Background: Attendees should be familiar with Java and object-oriented programming. Marco Pistoia is an Advisory Software Engineer, working at the IBM T. J. Watson Research Center in the Network Interactivity department. He has written nine books and taught classes world-wide on Java, WebSphere and e-business security. Marco's latest book, "Java 2 Network Security," is published by Prentice Hall PTR (ISBN 0-13-015592-6). Marco's interests are in mobile code security, security of collaborative systems, and object-oriented technology.

Explore the role and common challenges of software architecture found in modern object-oriented, distributed, and multi-tier systems. We look at the recent startling discoveries made by members of the patterns community investigating a variety of large real-life proprietary software systems and discuss the path of the new professional discipline: the software architect. An attendee will be able to address a number of critical design issues not commonly explored via UML or other popular modeling approaches that are nevertheless critical to the success of modern day, object-oriented, distributed, n-tiered systems. These issues include: system availability, security, scalability, survivability, long-lived flexibility, large scale granularity, data quality and maintenance, system metrics and reports, packaging and delivery mechanisms, as well as other key design decisions. Presentation Format: The teaching style is case-base driven, and hands-on in nature, with lecture intermixed to extend a participatory learning experience. As a result the attendee is assumed to have experience building at least one real-life software system of substantial size. Attendee Background: Minimum 3 years professional programming experience. Norm Kerth is a consultant working with mastering object-oriented technologies, including 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 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. Gerard Meszaros is a consultant working with clients making the transition to object and component-based technology. A key component of these transitions is establishing software architecture as a cornerstone of the methodology. Prior to becoming a consultant, he was a software architect and project manager overseeing the development of software for switching telephone calls, a field where high availability and capacity requirements force close attention to software architecture. Jim Doble has worked in a variety of software development, management, and architecture roles within the telecommunications industry for 18 years. Jim started his career with Nortel, working primarily on central office switching system software, spent two years with Allen Telecom developing cellular infrastructure products, and is currently employed as chief software architect for Motorolaís Personal Communications Sector, where he is responsible for developing architectures for future generations of cellular phones. In addition to architecture, Jimís technical interests include patterns, prototyping, and tools development.

This tutorial will demonstrate how to create the software architecture of an application or a system using a pattern language. An introductory, background presentation will argue that architectural knowledge is "configurational knowledge" which is expressed through high-level structure but is not reducible to it. Software Architecture impacts on organizational structure and the creative process as well as on the technical system itself. Pattern languages can capture and express architectural knowledge, and therefore guide design in all these aspects. A subset of patterns from the ADAPTOR pattern language (authored by Alan O'Callaghan), together with some of Kevlin Henneyís distributed patterns, will be presented. In the hands-on part of the tutorial, using supplied materials (reference cards, etc.) the attendees will be split up in groups and will be asked to utilize the patterns supplied to develop an outline solution to a case study. Cross-group as well as intra-group collaboration will be required for a successful outcome. Entitled WindowShopper, the specification will be a subset of a real, current development for the retail supply industry that has utilized the ADAPTOR patterns in its development. In a summary section, attendees will get the chance to critically review what they have experienced. Presentation Format: The format is a combination of lecture presentation (punctuated by short supportive exercises) to introduce the pattern language (2 hours) and a group-based exercise to develop an architecture based on a case study (4 hours). Attendee Background: Developers of all kinds (i.e., architects, designers, analysts, programmers, etc.) with experience with object technology are welcome, but those charged with maintaining the conceptual integrity of large, legacy, or distributed systems will benefit most. Alan O'Callaghan is a senior researcher at De Montfort University's Software Technology Research Laboratory. Alan has been at DMU since 1989, having previously worked for companies such as the London Transport Executive, BOC Ltd., and Kodak UK. His research focus is on software architecture, reuse, software patterns, and the migration of legacy systems. He is also a sought after consultant to industry and has been involved in major projects in the telecommunications, defence, retail, and embedded command and control system industries. He has edited two books on applied OT and is currently writing two more. He writes a regular column in Application Development Advisor (formerly Object Expert) on legacy system migration. Alan is the author of the ADAPTOR pattern language. Alan is a member of the BCS Object Oriented Programming and Systems specialist group national committee, the IEEE, and the ACM Computer Society. He also is a member of both the Institute of Analysts and Programmers, and World Wide Institute of Software Architects Kevlin Henney is an independent trainer and consultant focusing on C++, Java, OO, design, patterns, and software architecture. He has written and delivered numerous courses on C++, Java, OOD, patterns, distributed objects, and component architectures. He was with QA Training, the leading UK IT training company, for four years. Prior to that he worked as a software engineer for a number of companies. He has been working with OO since 1990, and is known in the UK for his articles and presentations on patterns, design, C++, and Java. He is a member of the BSI (British Standards Institute) C++ standards panel. He is a columnist for C++ Report and Java Report and has written many articles for a variety of other magazines and journals. He is much in demand as a conference speaker and has presented tutorials and workshops at many conferences.

All projects begin with an exploration into requirements, building products that drive the entire software development process. At this point in the development lifecycle, a lack of quality can significantly impact a project’s future. Problems encountered in the development lifecycle can often be traced back to an improper or incomplete understanding of the problem to be solved. A solid process for software requirements analysis can significantly improve your project’s chances of success. Whether you plan to write a detailed requirements document according to IEEE specifications, or you plan to capture requirements in a spreadsheet, a strong UML model that demonstrates your understanding of your customer’s requirements should be your first step. This tutorial outlines a process for building UML models that capture an understanding of what your team must accomplish, maximizing the effectiveness of your requirements-gathering process. In sum, this tutorial will demonstrate how to build a UML model that substitutes for a detailed requirements document or serves as the foundation upon which to build a detailed requirements document. Presentation Format: 90 minute presentation followed by 5 exercise segments where the attendees work in small teams following the process as outlined. Attendee Background: Software professionals looking for ways to effectively capture an understanding of their customers’ requirements. Mr. Tim Szymanski is an expert in object-oriented technology. As a known speaker and publisher in the field, Mr. Szymanski brings a fresh and down-to-earth approach to implementing OO technology. Mr. Szymanski currently supports technical sales and OO consulting with Advanced Software Technologies, a leader in UML modeling technology and OO training. Mr. Szymanski began his career with 8 years as an officer in the United States Air Force, involved in a variety of sophisticated military and communications technologies. Mr. Szymanski’s work experience also includes: Reltec Corporation and Gateway Computers where his area of focus involved process improvement, implementation of UML technology, and commercial application development. Mr. Szymanski graduated from the United States Air Force Academy in 1990 with a Bachelor of Science degree in Electrical Engineering. In 1994 he received a Master of Science degree in Computer Science from California State University Sacramento. He may be contacted at: tszymanski@advancedsw.com.

This tutorial shows how use cases can be written, cross-connected, and managed. There will be no presentation slides in this tutorial. We shall discuss, write, examine, and consider the results, using continuous group exercises and discussions. This format will allow us to develop some facility with the underlying concepts, and work at different levels of precision, prior to writing use cases at different levels. Expect to encounter differences in writing styles and to discover that use cases are trickier to write than they seem. Learn the degrees of variation that still permit use cases to be effective. Topics will include: usage narratives, system scope, actors, goal levels, the new stakeholders and interests model underlying use cases, scenarios, failure detection and handling, connecting use cases, and of course, dealing with UML. The objective is to give attendees the theory and practice needed to write use cases effectively. At least 2/3 of the course time is spent writing and discussing. Presentation Format: Lecture, writing exercises, group discussion. Attendee Background: Anyone who is faced with gathering behavioral requirements for a software system, or for business process modeling. Typically from an IT department, but possibly from the human factors group, marketing department, or a user community. Alistair Cockburn, founder of Humans and Technology, was special advisor to the Central Bank of Norway and designed the OO methodology for the IBM Consulting Group in the mid-1990s. His “Surviving OO Projects” was published in 1998. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair’s workshops and tutorials can be found at http://members.aol.com/acockburn.

Industry studies show that the most productive software developers are 20 to 200 times more effective than their least productive counterparts. No other engineering discipline shows this divergence in practitioner competency level. This tutorial will present some of the techniques that allow developers to be incredibly effective, often doing in one day what others take weeks to accomplish. The participants will apply these techniques “hands-on” to the analysis, design, and implementation of a substantial real-world application. They will learn strategies to avoid time-wasting activities and will see how to build in extensibility from the ground-up, addressing future requirements that may not have been anticipated. Participants also will learn how to solve problems by finding and applying pattern languages during analysis, design, and programming. By the end of the tutorial, participants will not only learn about, but also help to build an application, taking it from concept to a functional prototype in only a day. Presentation Format: Lecture, discussion, and hands-on workshop. Attendee Background: This tutorial will assume and build on the participant having a good familiarity with Object Modeling, UML notation, the general concepts of Patterns and Pattern Languages, and at least one year experience programming in an object-oriented language. Michael Anton is Director of Software Development at Financial Technology Solutions Inc., a firm specializing is software development for the financial industry. He was a Senior Management Consultant for the last two years at an investment management firm in New York City, where he was also Manager of Fixed Income Systems for four years. Mr. Anton holds a Master of Science in Engineering (Computer & Information Science) from the University of Pennsylvania and a Bachelor of Arts in Economics and Chemistry from Williams College in Massachusetts. He has over twenty years experience designing, building, and managing software projects. Mr. Anton has been involved in Object-Oriented Development for twelve years and has contributed to many dozens of projects in portfolio management and trading, molecular modeling, directional drilling, traffic control, office automation, Microwave CAD and interactive voice response. Soo Lee is a Senior Software Engineer with over ten years experience in Object-Oriented Software Development.

One of the major challenges faced by enterprise Java developers is overcoming the mismatch between objects and relational databases. Storing objects in Java is more than simple JDBC calls; a solid design incorporates a persistence layer that separates the details of the database from the business logic. The persistence layer should address mapping and run-time issues such as: caching, object identity, inheritance, legacy database integration, querying, stored procedure use, objects stored in multiple tables, and transaction management. Additional challenges arise as more projects use three-tier architectures and application servers. The Enterprise JavaBean specification has also added integration requirements as developers build EJB compliant server components. Participants in this tutorial will learn about the issues involved with storing Java objects and Enterprise JavaBeans in relational databases. The design considerations in building and using a persistence layer will be discussed. Presentation Format: The presentation format will be slides with interactive discussion Attendee Background: Participants should have a basic knowledge of Java, object modeling and relational databases. A high level knowledge of Enterprise JavaBeans would also be of use for the sections focused on EJBs. Dennis Leung is the Director of Product Management at The Object People. He manages the TOPLink family of object-relational mapping tools. He has consulted with Fortune 500 companies world-wide on object-relational issues. Dennis has spoken at several conferences including: Smalltalk Solutions, Java Developers Conference, OOP Munich, OOPSLA, Sun Java Developer Days, and Java Expo Europe.

eXtreme Programming (XP) is a lightweight software development methodology that emphasizes ongoing user involvement, automated testing, and pay-as-you-go design. This tutorial introduces XP practices through hands-on exercises: Planning Game: User Stories, On-Site Customer Programming Game: Test-First Programming, Unit Testing, Pair Programming Refactoring Game: Code Smells, Once-and-Only-Once, Refactoring The exercises are paper-based and use a robot programming language. Student Volunteers help play the part of the customer and the unit testing framework. As a participant, you will help create a live simulation of several key practices of eXtreme Programming. Presentation Format: About 2/3 audience exercises, 1/3 slides and discussion. Attendee Background: Some familiarity with object-oriented concepts is helpful; no prior experience with XP is needed. Steve Metsker has been learning and writing about computer science since Jimmy Connors was the extreme in tennis and Jaws was the extreme in fish. In his writing, Steve has pursued topics that empower programmers, with articles on interpreters, OO weights and measures, and object relationship modeling. In his work, Steve has come to believe in involving users early, hooking requirements to testing, automating testing, and refactoring code. eXtreme Programming consolidates these practices and more into a lightweight methodology that works. In his current job, Steve actively injects XP practices into real world application development. William Wake has been programming almost as long. He is interested in XP, patterns, human-computer interaction, and information retrieval. He is author (with Stephen Drye) of “Java Foundation Classes: Swing Reference,” as well as several articles on other topics.

Combining object-oriented technology with the World Wide Web can be a complex affair for any project manager. The visibility and distributed nature of the Web may force you to deal with a host of issues that you are not likely to experience when managing traditional client/server projects. You will face an incredible tension between scalability, stability, and time to market from various project stakeholders. We will try to pass on techniques from our own bag of tricks to navigate this minefield. This session will draw from our own experience in managing successful Enterprise Java projects rather than standard project management theory. Tutorial participants will (1) learn to build realistic project plans and work breakdown structures, (2) understand how to evaluate and select your proposed tools and technologies, (3) explore hiring and training issues, and (4) learn to avoid some of the most common pitfalls on object-oriented Web projects. Presentation Format: This tutorial will be 70% presentation based. The remaining 30% will be a deep and free form discussion between the presenter and the audience Attendee Background: Project managers and developers interested in building an object-oriented Web application the right way. Skyler Thomas is a Senior Consultant with IBM WebSphere Services. He has been an active leader in Object Technology for over ten years. He is a recognized expert in project management for n-tier systems. He is also one of the gurus in the emerging field of personalization. He has consulted internationally with many companies in the Banking, Insurance, and E-Commerce industries. He has spoken at conferences like OOPSLA 99, JavaOne 99, and WebSphere 2000, and has published several OO-related articles.

This tutorial’s purpose is to demystify metaclasses and demonstrate a theory of 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 metaclasses that do compose with each other. The attendee will attain an understanding of why metaclasses are a natural extension of object-oriented programming, how an object model with metaclasses can be easily programmed, how to construct a metaobject protocol, how metaclasses are composed, and what are some useful composable metaclasses. Presentation Format: Presentation. 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. Dr. Ira R. Forman works for IBM in Austin. As a member of IBM’s Object Technology Products Group, which produced the SOMobjects Toolkit, he worked on the SOM Metaclass Framework. 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. He is the coauthor of two books: “Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming” and “Putting Metaclasses to Work: A New Dimension in Object-Oriented Programming.”

Typical OO development techniques assume systems with relatively large memories. Developers working with tight memory requirements need the flexibility and encapsulation that OO can provide, but cannot afford to produce large systems. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using design patterns and practical examples, this tutorial will teach the most important techniques that successful OO designers use for small memory software. This tutorial introduces participants to the techniques required to develop OO systems in limited-memory environments. After attending this tutorial, participants will be able to: understand the forces involved in designing small systems; design memory-efficient object structures and appreciate when they are appropriate; trade-off memory consumption and system responsiveness; and gracefully handle memory exhaustion by offering by limited service. Presentation Format: This tutorial balances direct presentations (for overviews and to present each pattern) and case studies (to reflect on patterns and see how they can be applied). Attendee Background: This tutorial targets anyone planning, or involved in, development of OO applications in limited memory. This tutorial is most useful to developers with a year’s experience using an OO language and technical team leaders. Experience of memory-limited systems is helpful but not essential. Dr. James Noble has recently returned home to lecture at the Victoria University of Wellington, New Zealand. While in Sydney, he established the Sydney Patterns Group, the first patterns group in the Southern Hemisphere, and he has extensive experience lecturing, teaching, and mentoring with software design, user interface design, and design patterns. Charles Weir has more than fifteen years’ experience with software development and OO techniques. Charles was technical lead for two major EPOC ‘smart mobile phone’ projects, and software architect for the Psion Series 5 Web Browser. Charles has taught many courses on OO design and implementation, and has led many active-learning sessions at the UK Object Technology series of conferences and elsewhere. James and Charles are collaborating on a book, “Small Memory Software,” describing patterns for memory-constrained systems, to be published by Addison-Wesley in 2000.

Today’s software architects have to choose between three different database techniques: object databases, relational databases, and object-relational databases. All of these have different advantages and liabilities. Most vendor statements are not fully dependable because they overemphasize the advantages of their product without mapping them to real-world requirements. A database paradigm that does not fit the project’s requirements may result in several severe problems including unsolvable performance problems and even project crashes. This tutorial teaches architects to choose between the various techniques and to find the solution that best fits their project. It discusses the techniques from an unbiased perspective. Consequently it discusses basic paradigms rather than actual products. After the tutorial, attendees should: know what the basic database paradigms are understand the differences between them understand the forces that drive a selection know how each database paradigm affects these forces know how to set up an evaluation of a database paradigm. Presentation Format: The tutorial will be a lecture with group exercises on specific case studies. Attendee Background: This tutorial is aimed at experienced designers of data-intensive applications. They should have basic knowledge of one relational or object database and should feel comfortable with object-oriented design. Jens Coldewey is an independent consultant from Munich, Germany, specialized in deploying object-oriented techniques in large organizations. He has published several articles, papers, and patterns on both object-oriented and relational databases. Wolfgang Keller is a manager of reusable software components for Generali insurance group in Vienna, Austria. His responsibilities include the technical base for Generali’s Phoenix line of insurance applications, product architecture and project coordination for Generali’s distributed development across parts of Europe.

The widgets in the Java AWT and JFC collections supply the fundamental components that are required for the construction of standard user interfaces. However, many situations require more specialized components to be developed. This tutorial will expose the processes involved in first developing a specialized component and then upgrading it to become JavaBean compliant. This will be done within the context of designing for usability and reusability from the outset. After the tutorial, attendees will be able to: distinguish internal from external event handling illustrate internal event handling within the context of a specialized component demonstrate designing for usability by means of STDs describe a minimum set of methods that should be considered when developing specialized components consider the stated requirements of a JavaBean illustrate the stepwise refinement of a specialized component into a JavaBean and demonstrate it within a bean tool Presentation Format: Presentation and demonstration. Attendee Background: An advanced tutorial intended for attendees who are already familiar with the use of the AWT or JFC widget set and who wish to learn how to develop specialized components for particular requirements within the context of the JavaBean specification. Fintan Culwin is a Reader in Software Engineering Education at South Bank University: London specializing in Software Engineering and HCI, particularly in the integration of usability considerations in the earliest stages of production processes. He has published five books, including two on Java, and is currently completing a sixth on the JFC. He has published extensively on Internet issues and has presented sessions on the Web and Java at a series of international conferences including: SIGCSE ‘97, 98, & 99, BCS HCI ‘96, ‘97, & ‘98, ITiCSE ‘98, CHI ‘99, and OOPSLA ‘98 & ‘99.

This tutorial covers OMG’s Object Management Architecture including CORBA, the CORBAservices and CORBAfacilities, and the Domain CORBAfacilities. Starting with a brief look at requirements and needs in distributed Internet and enterprise computing and how UML, the MOF, and XMI support the rest of the OMG specifications, the tutorial moves on to cover OMG Interface Definition Language and mappings to various programming languages, the structure and function of the Object Request Broker, network interoperability and the standard protocols GIOP and IIOP, integration with Java and COM/DCOM, and the Portable Object Adapter (POA) and how it supports a scalable server-side infrastructure. After taking this tutorial, attendees will be able to judge if a project is suitable for CORBA, and move on to the next step in their own CORBA education, whether through books or formal training course. The tutorial also provides enough background to enable attendees to understand the companion OOPSLA tutorial “What’s New in CORBA 3?” Presentation Format: Presentation. Attendee Background: The tutorial assumes that attendees will be new to CORBA, but familiarity with OO concepts or an OO language will be helpful. Dr. Jon Siegel, OMG’s Director of Technology Transfer, heads OMG’s technology transfer program with the goal of teaching the technical aspects and benefits of the Object Management Architecture, including CORBA, the CORBAservices, the Domain specifications in vertical markets ranging from healthcare, life sciences, and telecommunications to manufacturing and retail systems, and the modeling specifications UML, MOF, and XMI. In this capacity, he presents tutorials, seminars, and company briefings around the world, and writes magazine articles and books including the popular “CORBA 3 Fundamentals and Programming.” With OMG since 1993, Siegel previously chaired the Domain Technology Committee responsible for OMG specifications in the vertical domains.

E-Business is about business-driven technology-enabled change that is much deeper than just Web-enablement. The challenges of an e-business transformation include things as diverse as integration of business processes, front- and back-office applications, the customer, the products, the competition, and continued agility. The e-business cycle includes everything from business objectives and analysis, architecture and implementation, deployment and operations monitoring, and eventual return on investment. It forces you to question and re-think fundamentals taken for granted previously, such as outsourcing arbitrary portions of a business’ processes. And it demands careful attention to architectural infrastructure. In this tutorial we examine specific aspects of component-based development and modeling that directly support an e-business transformation, using the UML/Catalysis approach. Participants will become acquainted with a component-based modeling and development framework that addresses many of the issues encountered in an e-business project in a consistent and cohesive way. Presentation Format: Mostly interactive presentation, with some optional short exercises to emphasize key concepts. Attendee Background: Participants should be familiar with both e-business and UML modeling. Desmond D’Souza is president of Catalysis.org. Developer of the Catalysis method for the systematic development of business-driven component systems, and co-author of a book on this topic published by Addison Wesley, he was previously senior vice president of component-based development at Computer Associates and Platinum Technology, responsible for defining methods, tools, and architectures for effective component-based software engineering. Desmond has worked with object and component technology since 1985, and is a frequent invited speaker and consultant at companies internationally.

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. Presentation Format: This tutorial will be presentation based. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is assumed that the attendee is familiar with basic OO concepts and has a working knowledge of the Java programming language. David Holmes is a Senior Research Scientist at the Cooperative Research Centre for Enterprise Distributed Systems Technology (DSTC Pty, Ltd.), in Brisbane, Australia. He completed his Ph.D. in the area of synchronization within object-oriented systems and has been involved in concurrent programming for a number of years. He is a co-author of the third edition of the Java Series book “The Java Programming Language.” Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book “Concurrent Programming in Java: Design Principles and Patterns,” co-author of the book “Object-Oriented System Development,” and the author of several widely used software packages, as well as articles and reports on object-oriented software development.

As the use of UML grows and UML is applied to more fields of software and systems engineering, the need for more precise specifications grows. This is crucial, for example, when generating code or test cases from specifications. In the component-based world we need to be able to specify the behavior of components in a very precise way. This enables us to know whether components are plug-compatible and can work together. For these purposes UML’s Object Constraint Language is becoming popular as a standardized and language independent specification mechanism. This tutorial shows the importance of constraints as an object-oriented specification technique and how they add value to the visual modeling techniques of UML. The OCL language itself and the connection with the visual UML diagrams are thoroughly explained. The final part of the tutorial will show how one can apply constraint modeling in UML to achieve the above-described goals. After this tutorial, the attendees will be able to understand the added value of constraints for their modeling and component based work. They will understand UML’s Object Constraint Language and know how it integrates with UML diagrams. Presentation Format: The tutorial is a mixture of presentation and small exercises. Attendee Background: The tutorial is targeted to people who have experience with analysis and design methods like UML. Jos Warmer has been active in the OT community since 1985. Currently he is working at Klasse Objecten as a senior consultant. He used to work within IBM’s European Object Technology Practice (OTP). Jos co-authored the UML 1.1 proposal for the OMG. He is still responsible for the UML Object Constraint Language with the OMG’s UML core team. He is the chief architect of OCL. Anneke Kleppe has over ten years of experience with object technology. Currently she is an independent consultant in the area of object technology within her own company called Klasse Objecten (in English that would translate to “Class Objects”). Her job is to coach and train companies working with object technology. Some of the companies she has worked for are PTT Telecom, NCR Nederland NV, IBM Education and Training, and the Dutch government. Anneke Kleppe and Jos Warmer are the authors of “The Object Constraint Language: Precise Modeling with UML,” part of the Addison Wesley’s OT series. They also authored two Dutch books: “Praktisch OMT” and “Praktisch UML” (translated: Practical UML), on OMT and UML. All books are published by Addison-Wesley.

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 course describes a set of fundamental design patterns and, through a design scenario, demonstrates how to build reusable object-oriented software with them. The course 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 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. Presentation Format: Presentation Attendee Background: Attendees should understand basic object-oriented concepts, like polymorphism and type versus interface inheritance, and should have had some experience designing object-oriented systems. No prior knowledge of design patterns is required. Familiarity with Java is recommended. John Vlissides is a member of the research staff at the IBM T. J. Watson Research Center in Hawthorne, NY. He has practiced object-oriented technology for over a decade as a designer, implementer, researcher, lecturer, and consultant. John is author of “Pattern Hatching,” co-author of “Design Patterns” and “Object-Oriented Application Frameworks,” and co-editor of “Pattern Languages of Program Design 2.” He is also Consulting Editor of Addison-Wesley’s Software Patterns Series. John has published numerous technical papers and is a columnist for the C++ Report.

The increased complexity associated with large-scale software development requires an increase in the sophistication of the methodology utilized. The third generation method/process RUP is described in detail and then evaluated for its efficacy in industry. This leads to suggestions to extend and recast it to remove its identified deficiencies. The result is the Object-oriented Process, Environment and Notation, or OPEN, method/process, a public domain, third-generation approach, which is then outlined. The overall aims of the tutorial are to critically evaluate RUP and OPEN as the two most viable OO/CBD (Component-Based Development) processes available today. Presentation Format: Lecture. Attendee Background: Fully conversant with basic OO terminology and the need for a full lifecycle process. Experience with OO methodologies is advantageous. This tutorial is of particular interest to project managers, systems developers, analysts, and designers who require information on modern OOAD methodological/process thinking. Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research (COTAR) and Professor of Information Systems at the University of Technology, Sydney (UTS). He is author of eight books on object technology and is well-known for his work in OO methodologies and metamodelling (MOSES, COMMA, and OPEN) and in OO metrics. He was recently voted number 3 in Who’s Who of Object Technology (“Handbook of Object Technology,” 1999, Appendix N).

Reflection is a programming technique for object-oriented architectures to provide better extensibility of a system (especially at run-time) and means for uniform generic behavior (such as persistency). While languages like Smalltalk and Java provide built-in mechanisms for reflection, C++ lacks such a provision. Though several well-known patterns exist for implementing reflection through a metaobject protocol in C++, they typically require the usage of this protocol for all access to the real (non-meta) classes, forcing an unnatural style of programming. This tutorial presents some lesser-known C++ constructs that can be used to provide metaclass facilities to existing normal C++ classes, enabling both normal direct access and reflective access to these classes. Participants will acquire a thorough understanding of the potentials of reflective programming techniques and some patterns to implement them effectively in C++. One major application of the presented techniques will be shown in the tutorial “XML Dynamically with C++.” Presentation Format: Presentation based. Attendee Background: Participants should have a good working knowledge of ISO C++. Advanced features of the language used in this tutorial will be explained. Detlef Vollmann has a background of 15 years in software engineering and more than 10 years with object technology. As an independent consultant he supports several Swiss companies with the design of object-oriented systems. Since 1991 he has authored and taught courses in C++, Object-Oriented Technologies, Software Architecture, and Distributed Computing for Swiss Digicomp AG.

This tutorial is for people who want to find out more about eXtreme Programming with an eye toward improving the software development process. Managing the incremental, iterative development processes required by modern software systems is not easy, so it is useful to see what lessons can be learned from the process that has taken incremental development to extremes. eXtreme Programming projects manage to be successful with a 3 week delivery cycle, incrementally gathering requirements and adding fully tested, useful system features every increment. This tutorial is intended to prepare the participant to become actively involved in experimenting with and tuning their current development process. Presentation Format: This tutorial will be an inquiry directed through the use of presentation material. For each of the lessons identified there will be group inquiry and discussion about the applicability of the lesson to other development processes. Attendee Background: The tutorial is targeted to those individuals interested in identifying individual and group software development practices that will allow them to improve their delivery capability. Pete McBreen is a course designer, teacher, and project lead in object technology. He is responsible for ensuring that project teams make effective use of object technology on projects including project startup, methodology and tool selection, mentoring, process improvement, system design, and quality assurance. With over 15 years of industry experience, he has been successfully using and teaching OO techniques since 1989.

The Catalysis method (www.catalysis.org) provides a simple and consistent use of UML to: (a) treat “objects” and “use cases” in a fractal manner, from business to code, (b) specify and design large-grain to small components using “types” and “collaborations,” (c) use a “plug-in” framework approach from requirements patterns, through architecture and design, to code, and (d) define component architectures based on an extensible “kit” of architectural modeling elements. This tutorial provides an overview of the key concepts and the development process. Participants will learn how to model components in an abstract yet precise way, how to relate component models to business requirements, and how to use modeling patterns as building blocks for everything from requirements through design. Presentation Format: Mostly presentation. Attendee Background: Attendees should be familiar with object modeling and programming, design patterns, and use cases. Those wanting to use patterns with UML, seeking a consistent component-based approach from requirements to code, and using languages like Java, will particularly benefit. Desmond D’Souza is president of Catalysis.org. Co-author and developer of the Catalysis method for the systematic development of business-driven component systems, and a book on this topic published by Addison Wesley, he was previously senior vice president of component-based development at Computer Associates and Platinum Technology, responsible for defining methods, tools, and architectures for effective component-based software engineering. Desmond has worked with object and component technology since 1985, and is a frequent invited speaker and consultant at companies internationally.

The last twenty years have seen a lot of work in modeling methods: techniques to help people understand how software works. In the last few years the Unified Modeling Language (UML) has become the standard notation for describing object-oriented designs. This tutorial gives you an outline of the UML and additional useful techniques. We’ll cover such techniques as Use Cases, Class Diagrams, and Interaction Diagrams, together with non-UML techniques like CRC Cards and Design by Contract. We’ll also see how these techniques fit into a simple incremental development process. This tutorial is a Grand Tour of the UML. There isn’t time in half a day to go into great detail on any of the techniques within it, but there is a chance to get a feel for what each technique looks like, when to use it, and where to find out more. You’ll also get tips on using them from someone with plenty of object-oriented scars. Presentation Format: Lecture. Attendee Background: Attendees should be familiar with basic OO concepts. Craig Larman is the author of “Applying UML and Patterns–An Introduction to Object-Oriented Analysis and Design,” the best-selling text on object-oriented analysis and design and the UML. He also co-authored the “Java 2 Performance and Idiom Guide” and writes the “Modeling and Java” column in Java Report. Craig is a popular conference speaker, and conference or advisory board member, at events such as OOPSLA, Software Development, and UML World. Craig serves as Director, Process and Methodology, at Valtech, an international consulting group with divisions in Europe and the USA. He has been using object technologies since 1984 when he started developing knowledge systems on LISP machines. For many years he has assisted others in developing object systems, adopting practical development processes, and in learning to apply object-oriented analysis and design, C++, Java, and Smalltalk. Craig holds a B.Sc. and M.Sc. in computer science, with research emphasis in artificial intelligence, object-oriented knowledge representation, and case-based reasoning.

Smart, well-designed, and correct C++ programs can sometimes be highly inefficient. In many cases it is possible to dramatically reduce these efficiency problems (without giving up the abstraction) using a variety of techniques and idioms. This tutorial presents a series of C++ programming idioms for writing efficient C++ programs. The tutorial looks at class and class hierarchical design, the efficient use of the STL containers and generic algorithms, and such issues as locality of declaration and the Proxy design pattern. Participants will gain an understanding of the underlying C++ object model and language idioms in support of that model. With this knowledge, the participants should find themselves programming more efficiently and with more confidence. Presentation Format: Presentation and demonstration. Attendee Background: The attendees should be familiar with the standard C++ programming language. Stanley Lippman is a member of technical staff at DreamWorks Feature Animation where he is currently technical lead for a real-time Pencil Test system with audio synchronization. Prior to this, Stan was a principal software engineer at Walt Disney Feature Animation, and a member of technical staff at Bell Laboratories where he was involved in the development of C++. He is the author of “C++ Primer” (co-authored with Josee Lajoie), “Inside the C++ Object Model,” and “Essential C++.”

Typical OO development techniques assume systems with relatively large memories. Developers working with tight memory requirements need the flexibility and encapsulation that OO can provide, but cannot afford to produce large systems. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using design patterns and practical examples, this tutorial will teach the most important techniques that successful OO designers use for small memory software. After attending this tutorial, participants will be able to: Prepare a memory budget Design a software architecture and component interfaces to minimize memory use Track memory consumption through the development process, and Tailor user interfaces for small software Presentation Format: This tutorial balances direct presentations (for overviews and to present each pattern) and case studies (to reflect on patterns and see how they can be applied). Attendee Background: This tutorial targets anyone planning, or involved in, development of OO applications in limited memory platforms. This tutorial is most useful to developers with a year’s experience using an OO language and technical team leaders. Experience of memory-limited systems is helpful but not essential. Dr. James Noble has recently returned home to lecture at the Victoria University of Wellington, New Zealand. While in Sydney, he established the Sydney Patterns Group, the first patterns group in the Southern Hemisphere, and he has extensive experience lecturing, teaching, and mentoring with software design, user interface design, and design patterns. Charles Weir has more than fifteen years’ experience with software development and OO techniques. Charles was technical lead for two major EPOC ‘smart mobile phone’ projects, and software architect for the Psion Series 5 Web Browser. Charles has taught many courses on OO design and implementation, and has led many active-learning sessions at the UK Object Technology series of conferences and elsewhere. James and Charles are collaborating on a book entitled “Small Memory Software” describing patterns for memory-constrained systems, to be published by Addison-Wesley in 2000.

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 challenging to implement efficiently, three classes of implementation techniques are presented. First, run-time system techniques such as virtual function dispatch tables (including complications due to multiple inheritance and virtual inheritance) and inline caches are described. Second, static intra- and inter-procedural analyses are discussed that seek to identify at compile-time the possible classes of message receivers, in order to reduce or eliminate the overhead of dynamic binding. 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++, and Cecil. Attendees will become familiar with the issues and state-of-the-art techniques for implementing object-oriented languages efficiently. Presentation Format: This tutorial will be presentation based. 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, POPL, PEPM, and TOPLAS on the topic. For his Ph.D. thesis at Stanford, he developed the first efficient implementation of the Self language, using optimizing dynamic compilation. Chambers is currently an Associate Professor of Computer Science & Engineering at the University of Washington, where he designed the Cecil language, heads the Vortex whole-program optimizing compiler project, and co-leads the DyC staged dynamic compilation project.

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

Recent additions to the set of OMG standards bring CORBA into the world of modern networking: the Internet and corporate intranets, with their requirements for high throughput and large numbers of objects storing correspondingly large amounts of data, as well as specialized environments such as real-time and embedded systems. Under the banner CORBA 3, these additions fall into three major categories: Java and Internet Integration, including a reverse mapping from an Java to OMG IDL, an IIOP Firewall specification, and a definition of URLs for CORBA objects on the Internet Quality of Service Control, including a complete set of asynchronous and messaging invocation modes, QoS management, and specifications for Real-Time, Embedded (minimal), and Fault-Tolerant CORBA The CORBA Component Model (CCM), which packages up the most successful server development patterns into a sophisticated development and run-time environment After taking this tutorial, attendees will be familiar with all of the different parts of the CORBA 3 specification. Presentation Format: Presentation Attendee Background: Attendees should be familiar with fundamental CORBA concepts. Attendance at the companion tutorial “Introduction to OMG’s CORBA and Object Management Architecture” is sufficient. Jon Siegel, Ph.D., OMG’s Director of Technology Transfer, heads OMG’s technology transfer program with the goal of teaching the technical aspects and benefits of the Object Management Architecture including CORBA, the CORBAservices, the Domain specifications in vertical markets ranging from healthcare, life sciences, and telecommunications to manufacturing and retail systems, and the modeling specifications UML, MOF, and XMI. In this capacity, he presents tutorials, seminars, and company briefings around the world, and writes magazine articles and books including the popular “CORBA 3 Fundamentals and Programming.” With OMG since 1993, Siegel previously chaired the Domain Technology Committee responsible for OMG specifications in the vertical domains.

As more and more business is done over the Web, the notion of accessing and using software over the Internet not only by humans using browsers but also by portals and other applications has become increasingly popular. Building systems of such remote applications – often referred to as e-services – has its special technological and methodological requirements. Participants will learn about: E-Services: What are e-services? How are they different from distributed objects in an Intranet? E-Speak: Get a basic understanding about the requirements and characteristics of e-services platforms, taking e-speak, an open source platform for deploying e-services (http://www.e-speak.net), as example. We will discuss issues like pay per use, service advertisement, service brokering, communication mediation, firewall piercing using WebAccess, and requesting e-services by exchanging XML documents. Architecting e-services systems: What are the processes and models for defining e-services and e-services contracts and determining the overall architecture of e-services systems? How do you document the architecture of e-services systems? What are the similarities and differences to architecture models and processes of traditional systems? Presentation Format: The style of the tutorial will be mainly presentation, with an example to work on during the second half of the tutorial about designing an e-services system. Attendee Background: This tutorial is aimed at software engineers, architects, project managers. Basic familiarity with C++ or Java and UML is preferable. Dorothea Beringer is a consultant in the architectural consultancy group in Hewlett Packard’s Product Generation Services where she provides support to architects in designing and recapturing the architecture of software and firmware products and product lines. She has a Ph.D. in software engineering, has been publishing and teaching in academia and industry, and has lately researched e-services at Stanford University. Derek Coleman leads the architecture practice in Hewlett-Packard’s Product Generation Consultancy. His current research interest is in all aspects of the development of software, firmware, and product architectures. Derek is also a Visiting Professor at Kings College, London. Until he rejoined Hewlett-Packard in 1998, Derek was Head of Department of Computer Science at King’s. Prior to this, Derek was a manager at HP Labs in Palo Alto and Bristol (England). At Bristol, Derek led the development of the original Fusion Method. Derek has presented tutorials at OOPSLA, ECOOP, Software Development, UML World, and many other conferences. He is also regularly involved in developing and presenting training courses and webcasts to HP audiences. Mike Ogush is a member of the architecture practice area in Hewlett-Packard’s Product Generation Consultancy. His research interest is applying the front-end of the software development process (requirements through design) to the development of product lines and solutions. Since 1991, Mike has developed materials for, and lead training courses on, Software Architecture, UML for Software development, the Fusion OO analysis & design process, as well as briefer presentations and webcasts on reuse, requirements, architecture, and design. Between 1978 and 1991, Mike developed applications directed at improving programmer, software engineer, and circuit board designer productivity.

Through targeted exercises, attendees are introduced to real-world issues and solutions of enterprise-level component-based development using EJB/J2EE. The context is development of data-centric, transactional, e-business, and distributed systems that must scale at development-time and at run-time. The solutions proposed by the presenter are justified through a brief formalization of the concepts, including a detailed analysis of the differences between distributed objects and well-designed enterprise components, various architectural styles (e.g., instance-based vs. type-based, state-based vs. stateless) and relative scalability, approaches to persistence required by large systems, and generally speaking the main architectural principles required for scalable distributed systems. The tutorial covers shortcomings of the J2EE specification, and situates EJB/J2EE in the larger context of serious component-based systems for the enterprise. Attendees will come away with a detailed understanding of the issues, principles, and approaches required to use J2EE/EJB for large-scale distributed system development Presentation Format: 40% interactive exercises, 30% discussing presenter’s solution, 30% concepts formalization. Attendee Background: Participants should have a general familiarity with distributed system development issues, and preferably with object-oriented analysis and design. Familiarity the J2EE/EJB specification is recommended. The intended audience is professionals charged with architecting, developing, or managing large-scale distributed systems with EJB/J2EE Peter Herzum, co-founder and Chief Technology Officer of Vayda & Herzum, is considered the guru of component-based development for the enterprise. Peter is the creator of the Business Component Approach, the first approach entirely based on components, and principal author of the groundbreaking book, “Business Component Factory: A Comprehensive Overview of Component-Based Development for the Enterprise,” which has been described by analysts as “the bible of e-business component development.” Peter has over 15 years experience in the industry, and he has led large-scale component-based product development and solution development since 1992. Peter also has extensive experience in consulting, mentoring, and training for large organizations. He is a frequent speaker at conferences across the world (including tutorials at OOPSLA‘99, OOP2000, ObjectWorld, Component Development, SIGS Java Development, XML ONE, and others), and an active member of the OMG. Peter holds a Dr. Eng. degree in Computer Science from the Politecnico di Milano.

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

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. Presentation Format: Presentation. 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 is author of “Pattern Hatching,” co-author of “Design Patterns” and “Object-Oriented Application Frameworks,” and co-editor of “Pattern Languages of Program Design 2.” He is also Consulting Editor of Addison-Wesley’s Software Patterns Series. John has published numerous technical papers and is a columnist for the C++ Report.

The challenges in constructing effective real-time software systems usually extend far beyond the obvious problem of achieving timeliness. To properly analyze and describe such systems requires high-level abstractions and tools that are not normally available in modern programming languages. The Unified Modeling Language (UML), a standardized modeling language with a rich set of concepts, provides the necessary foundations for this purpose. This tutorial is organized around four central topics. First, we describe the relationship between the object paradigm and real-time systems. This is followed by an overview of UML, its concepts and diagram types, with particular emphasis on how those elements are used for real-time system construction. Next, we examine the central issue of time and time modeling with UML. Finally, we show how the UML can be used as an architectural description language to model the architectures of complex real-time systems Presentation Format: Presentation. Attendee Background: Experience with real-time software is required; OO programming experience is useful but not crucial. Bran Selic is Principal Engineer at Rational Software. He has over 25 years of experience with industrial real-time systems in telecommunications, aerospace, and robotics. He is the principal author of a popular textbook on the use of the object paradigm in real-time applications and was one of the members of the core team responsible for defining the UML standard within the OMG. Most recently, he has been working on defining the precise semantics of the UML and also on defining a profile for using the UML in the real-time domain. Mr. Selic has lectured extensively on the latter topic and is a frequent invited speaker at various technical and scientific conferences. He is also a member the editorial board of several technical publications, an adjunct professor at Carleton University, and is serving on the Industrial Advisory Board of the School of Information Technology and Engineering at the University of Ottawa. He is the general chair of the upcoming UML 2000 technical conference and is the industrial program chair of the IEEE Symposium on Object-Oriented Real-Time Computing (ISORC 2000).

This tutorial lets you experience the evolution of an object-oriented design from an initial class to a full-blown real-world framework. It is structured as a sequence of evolutionary steps, each of which adds new required functionality to the design. At each step, we learn new techniques that let us cope with the increasing complexity of the design. In its first part, we discuss the effective use of classes and interfaces for modeling and code reuse, design by primitives and the narrow inheritance interface principle, and the use of method types and design by contract. In its second larger part, we discuss the use of design patterns and their composition in object-oriented design. We see how objects collaborate while playing roles and learn how to break up complex designs into patterns and UML collaborations. On this basis, we learn how to best extend object-oriented frameworks and how to be precise about requirements put upon use-clients. Finally, we discuss how to define the resulting framework as a component with well-defined boundaries. Attendees learn new techniques for coping with the complexity of object-oriented frameworks. Each technique matches a specific level of complexity so that attendees learn to better choose techniques for their problems. Presentation Format: Presentation based. Attendee Background: Attendees are expected to be familiar with Java and UML. Dirk Riehle is a software developer at Skyva International. Dirk holds a Ph.D. in computer science from ETH Zurich. He has given many presentations at research and commercial conferences and has lectured at University of Zurich. At OOPSLA, he may be best known for his technical paper presentations. His research and technical interests revolve around model-driven business systems, business modeling languages, and software architecture. He has published extensively on object-oriented design patterns, frameworks, and software architecture.

The Internet and e-business change software project management. Extreme pressures (high speed, high change, and uncertainty) require that we alter time-honored views on how projects are managed. Adaptive Software Development focuses on shared understanding (rather than documents); results, people, and skills (rather than process); collaboration and group decision-making. Adaptive Software Development presents a new iterative life cycle—Speculate, Collaborate, Learn—and practices relevant to each of these phases. Rooted in Complex Adaptive Systems theory, adaptive development revels in a non-linear, non-deterministic view of the world, at the edge of chaos, where planning is tenuous and control impossible—a world of adaptation, not optimization. ASD is results driven rather than process driven. The workshop also introduces a futuristic management model—Leadership-Collaboration—to replace the antiquated Command-Control model. Participants will learn the basics of Adaptive Software Development and engage in hands-on exercises for creating a mission-driven, component-based, iterative project plan. Presentation Format: The workshop will be 40% lecture and 60% team-based exercises including some “fun” with “The Bead Game” simulation. Attendee Background: The tutorial is targeted at software development managers, project managers, and team leaders. Basic project management knowledge will be helpful. Jim Highsmith, is President of Information Architects, Inc., author of “Adaptive Software Development: A Collaborative Approach to Managing Complex Systems,” and editor of e-business “Application Delivery.” He has 30 years experience as a consultant, software developer, manager, and writer. Jim has published dozens of articles in major industry publications. In the last ten years, he has worked with both IT organizations and software companies in the US, Europe, Canada, and New Zealand to help them adapt to the accelerated pace of development in increasingly complex, uncertain environments.

E-business components meet others they have never met before, do business, move on. Some contacts will be regular, others transient; all involve negotiation, establishment of a common language, contracts. In the past, interoperability standards were restricted within particular businesses, and largely inflexible. For effective e-business, all components need to be able to interoperate at some level, any pair able to work out what they can achieve together – whether just the basic idea of a sale, or a more detailed understanding between components in the same business sector. These negotiations require reference to Web-accessible common standards for interface models. We need the standards to share common parts to enable interoperation between business sectors, and models should be able to be combined to make others. We need the models to cover not just the syntax, but the semantics of rules and operations. To check to what extent components are interoperable, we need to understand the rules of trait composition, and be able to apply them dynamically. And to be sure that components really conform to the traits they claim to, we need to be able to express the specifications in terms of concrete test schemes. This tutorial will discuss the issues in setting up an architecture of open standards in which widely differing components can understand each others’ capabilities and thereby negotiate unambiguous communication. Presentation Format: The tutorial will be largely doing rather than listening. Presentation will consist of cycles of: presentation of issue exercise in groups discussion of the outcome Attendee Background: Software developers. Alan Cameron Wills is Principal Consultant with Trireme International Ltd. He has been mentoring in software development since 1991, working with clients in telecoms, finance, and commerce in various parts of Europe and the USA. Alan is joint author of “Objects, Components and Frameworks in UML – the Catalysis Approach.” He is a frequent conference presenter, is Tutorials Chair of TOOLS Europe 1999 and 2000, and serves on the panels and committees of several other events.

This tutorial discusses ten advanced principles of object oriented design and dependency management in the context of UML. Students will learn the basics of UML notation, and how to apply it in the context of object-oriented design. Principles include the Open Closed Principle, The Dependency Inversion Principle, and the Stable Abstractions Principle. Topics range from detailed techniques for designing classes, to principles for partitioning classes into packages, to design metrics for measuring various qualities of an object oriented design. Presentation Format: Lecture. Attendee Background: Programmers with at least 1 year experience programming in an object-oriented language. Robert C. Martin has been a software professional since 1970. He is president of Object Mentor Inc., a firm of highly experienced experts that offers high level object-oriented software design consulting, training, and development services to major corporations around the world. In 1995 he authored the best-selling book “Designing Object Oriented C++ Applications using the Booch Method,” published by Prentice Hall. In 1997, he was chief editor of the book “Pattern Languages of Program Design 3,” published by Addison Wesley. In 1999, he was the editor of “More C++ Gems” published by Cambridge Press. From 1996 to 1999, he was the editor-in-chief of the C++ Report. He has published dozens of articles in various trade journals, and is a regular speaker at international conferences and trade shows.

This tutorial is a working session to help you produce effective use cases for functional requirements. We will go beyond simple examples to deal with many of the issues you will face (and we have faced!) in dealing with different kinds of systems, clients, and developers. We will look at some specific topics, such as how use cases relate to business process models, using generic use cases, distinguishing envisioning from designing, estimating development effort from use cases, and system exceptions. We will also look at the process of running use case workshops, and at the relation between use cases and other requirements artifacts such as the business rules catalog and non-functional requirements. After this workshop you should be better at using use cases, and more confident of continuing to improve your technique. Presentation Format: All this work will be dealt with in a highly interactive session, using hands-on exercises and case studies, and with plenty of opportunity to learn from each other. There will be supporting presentation and reference material. Attendee Background: You should have written some use cases and have experience of producing requirements documents. Knowledge of OO would be useful but is not essential. Bruce Anderson, Senior Consultant in IBM Component Technology Services, has been using use cases in his consulting work for several years. He has worked with clients in the banking, insurance, petroleum and telecom industries. Bruce served on the OOPSLA‘98 use case panel, and taught a tutorial on use cases at OOPSLA‘99. Paul Fertig, Senior IT Architect in IBM Business Innovation Services, has been responsible for requirements gathering and architecture in large services contracts for a number of years. He has worked with clients in the telecom, retail and investment banking industries. Paul co-authored a book on OO applications that has been a key influence on IBM’s world-wide software development method.

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) patterns and frameworks to alleviate the complexity of developing concurrent and distributed communication software. These patterns and framework components have been used successfully by the speaker on production communication software projects at hundreds of commercial companies for telecommunication systems, network management for personal communication systems, electronic medical imaging systems, real-time avionics, distributed interactive simulations, and automated stock trading. Upon completing this tutorial, attendees will be able to: Understand precisely how object-oriented techniques and tools can and cannot help to alleviate communication software complexity. Apply key object-oriented design techniques (such as patterns, frameworks, and components) to develop reusable communication software artifacts. Understand advanced OS capabilities and use them effectively to develop extensible, robust, reusable, and efficient concurrent communication systems. Know where to find additional sources of information on how to successfully apply object-oriented techniques to communication systems. Presentation Format: Lecture style. 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 Electrical and Computer Engineering department at the University of California, Irvine. In the spring of 2000, he will be transitioning to a Program Manager position at the DARPA Information Technology Office (ITO). Dr. Schmidt was formerly the Director of the Center for Distributed Object Computing 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 middleware on parallel processing platforms running over high-speed ATM networks and embedded system interconnects. Dr. Schmidt is an internationally recognized and widely cited expert on distributed object computing patterns, middleware frameworks, and Real-time CORBA, and has published widely in top IEEE, ACM, IFIP, and USENIX technical journals, conferences, and books. His publications cover a range of experimental systems topics including high-performance communication software systems, parallel processing for high-speed networking protocols, real-time distributed object computing with CORBA, and object-oriented design patterns for concurrent and distributed systems.

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. It discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the UML. It also provides an overview of how architectures drive the development process and how to capture proven architectural design patterns in the UML. The objective of this tutorial is to give the attendees the guidelines on how to use the UML to describe the architecture of a software-intensive system, how to express architectural patterns in UML, and how to (re)use them. Presentation Format: The tutorial will be primarily lecture, but we will encourage active participation by inviting questions and challenging the audience with common or exemplary problems. Attendee Background: Basic understanding of the UML is helpful, but not essential. Understanding of and practical experience with a software development process are helpful. Dr. Wojtek Kozaczynski is the Director of Architecture Practice at Rational Software. This new practice focuses on helping customers of Rational successfully develop architectures of complex, software-intensive system. Dr. Kozaczynski has 20 years of industrial and academic experience. Prior to joining Rational he was the chief architect at an ERP company and prior to that he directed a software engineering research and development laboratory at Andersen Consulting. He has consulted on and led development of large distributed commercial systems. He developed tools for distributed systems design and tools for software analysis. He also has extensive database background. Dr. Philippe Kruchten is the Director of Process Development at Rational Software Corp. He has 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 been with Rational Software for 11 years, consulting on issues of design and object-technology. As a technical consultant he led software architecture development for the Canadian Automated Air Traffic Control System. He has been involved in the development of the programming language Ada and worked for European telecommunication manufacturer Alcatel designing telecom switches.

C++ provides a context for design and expressing design. It offers a number of mechanisms that may be used to express design, working from problem to solution. Principles can organize mechanisms into a more useful framework. For instance, given that low coupling and high cohesion are desirable properties, what mechanisms are available to C++ developers to reduce dependencies in a large application? Exceptions are a part of modern C++ and threading is commonly available on many operating systems, but what idiomatic practices ensure that code is safe in the presence of different control flow models? How do features such as operator overloading, const, and templates support a more general approach to abstraction than inheritance alone? This tutorial focuses on describing contemporary techniques used at the idiomatic level in ISO/ANSI C++. This includes a few conventional design patterns and traditional C++ idioms, but the main focus is on those that are indigenous to modern C++. Presentation Format: The tutorial is based around lectures and discussion. Attendee Background: The tutorial is suitable for developers with intermediate to advanced C++ skills. Existing familiarity with patterns is not required. Kevlin Henney is an independent trainer and consultant focusing on C++, Java, OO, design, patterns, and software architecture. He has written and delivered numerous courses on C++, Java, OOD, patterns, distributed objects and component architectures. He was with QA Training, the leading UK IT training company for four years. Prior to that he worked as a software engineer for a number of companies. He has been working with OO since 1990, and is known in the UK for his articles and presentations on patterns, design, C++, and Java. He is a member of the BSI (British Standards Institute) C++ standards panel. He is a columnist for C++ Report and Java Report and has written many articles for a variety of other magazines and journals. He is much in demand as a conference speaker and has presented tutorials and workshops at many conferences.

It is hard to believe that more than thirteen years have passed since Frederick Brooks wrote his classic article and coined a new data processing vocabulary term: “Silver Bullet”. As Brooks wrote in 1986, unlike the werewolf, which could only be killed by a silver bullet, we haven’t been able to develop a silver bullet to help kill the software project beast of missed schedules, overblown budgets, and the production of flawed software products. Brooks also points out that there was no silver bullet in sight, either, from the world of technology or management. My goal is to show you how to write better software. By integrating the object-oriented language C++, the UML, and the Rational Unified Process, we will perhaps have enough silver components to at least stun the beast of poor quality and bug-ridden software – perhaps even knock it on its hairy rear end. Although we might never be able to truly kill it, we will have some great ammunition. We just need to make sure we use it properly. Presentation Format: Highly interactive, some whiteboard drawing, candy, toys and bugs. Attendee Background: A desire to finally understand all the gobbly-gook terminology and technology associated with object-oriented analysis and design. Michael S. Sandberg published his first book, “Monster C++: An Introduction to Object-Oriented Programming using C++ and the Unified Modeling Language (UML),” in 1998. He has had several articles published and is a frequent speaker at conferences including ones at IBM and Microsoft.

This tutorial presents, in detail, a part of a concrete real-world system and shows how it is designed with patterns. The system is for the representation of physical storage in a warehouse management system. Step by step we will re-play the process of the system’s construction. We discuss the design problems that occur, present the patterns that could help in solving these problems, discuss design alternatives, and show how we actually applied the patterns that were selected. By this process, we will see how the design of the system slowly grows and evolves towards the final architecture. We will also see and discuss how patterns are applied in practice and how they help building high-quality software with predictable properties. The tutorial concludes with a summary of our experiences from several projects in which we applied patterns: what worked, what could be improved, and what we learned. Presentation Format: Presentation. Attendee Background: Sound knowledge of object technology, knowledge of UML notation, knowledge of the pattern concept. Knowledge of specific patterns is helpful, but not required. Frank Buschmann is Software Engineer at Siemens Corprate Technology in Munich, Germany. His research interests include Object Technology, Software Architecture, Frameworks, and specifically Patterns. He has published widely in all of these areas, notably as co-author of Volume 1 of the “Pattern-Oriented Software Architecture series: A System of Patterns,” and the upcoming Volume 2: “Patterns for Concurrent and Distributed Objects.” In his development work, Frank has led design and implementation efforts for several large-scale industrial software projects, including business information, industrial automation, and telecommunication systems.

The competition to grab eyeballs is quite intense. Creating a unique and personalized Web experience is the best way to win customers and keep them coming back for more. This session will explore the ways that we have used OO technologies to amaze our biggest customers. We will attempt to fill in all the details necessary to form a coherent personalization solution using Java technology like EJBs, JSPs, and Servlets. You can use these tools to customize the look and feel of your Website in extremely complex ways. Even more advanced and exciting is the ability to establish a profile for your users without them ever having to fill out long and tedious preference forms. This tutorial will explore the entire lifecycle of a personalization project. We will dig deep into the relevant technologies and give you our first hand project experience. This tutorial will prepare the participants to (1) begin to deploy Java personalization technologies, (2) address the performance issues of personalization, and (3 understand the privacy issues in deploying a personalized solution. Presentation Format: This tutorial will be 70% presentation based. The remaining 30% will be a deep and free form discussion between the presenter and the audience. Attendee Background: Anyone interested in building a richly personalized Website. Skyler Thomas is a Senior Consultant with IBM WebSphere Services. He has been an active leader in Object Technology for over ten years. He is a recognized expert in project management for n-tier systems. He is also one of the gurus in the emerging field of personalization. He has consulted internationally with many companies in the Banking, Insurance, and E-Commerce industries. He has spoken at conferences like OOPSLA 99, JavaOne 99, and WebSphere 2000, and has published several OO-related articles.

This tutorial explores how Enterprise Application Integration (EAI) in conjunction with object-oriented technology allows organizations to move information between one or more systems, thus increasing the value of those systems in the enterprise. Focusing on the creation of composite applications for EAI, the content of the tutorial will first focus on the basic notion and concepts of EAI, then approaches and technology for implementing EAI, including frameworks and distributed objects. Presentation Format: Lecture Attendee Background: Understanding of basic middleware and object-oriented concepts. David S. Linthicum is the CTO of SAGA Software, Inc. in Reston Virginia and an internationally known EAI and e-business expert. In his career, David has formed many of the ideas for modern distributed computing including EAI (Enterprise Application Integration) and B2B application integration, approaches and technology in wide use today. In addition, David has authored over 300 articles for major computing publications, and has monthly columns in several popular industry magazines. David has authored or co-authored six books including “David Linthicum’s Guide to Client/Server and Intranet Development,” and the ground breaking “Enterprise Application Integration,” just released. Before joining SAGA Software in 1997, David held key technology management rules with a number of organizations including Mobil Oil, EDS, AT&T, and Ernst and Young. In addition he was an associate professor of computer science for eight years, and continues to lecture at major technical colleges and universities. David has presented keynotes at many leading technology conferences including Software Development, eBusiness World, EAI Summit, Computing Without Bounds, eB2B, iEC, and Comdex.

While the Unified Modeling Language (UML) is 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 business analysts and developers. 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. It explains the application of use case, activity, and class diagrams to business modeling. It also describes how business rules can be incorporated into those diagrams. Attendees will learn 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. Presentation Format: Lecture. 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. Charles Richter has been involved in object-oriented development for over ten years, and has been teaching and mentoring object-oriented analysts and designers for most of that time. He has been using and teaching UML since the notation’s inception. 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 and Java programming. He is the author of the book, “Designing Flexible Object-Oriented Systems with UML,” published by Macmillan Technical Publishing.

This tutorial provides the attendee with a broad view of testing, including quality-related issues such as inspections and reviews in addition to static and dynamic testing of code. It relates the quality of the design methodology being used to the correctness of the software. A number of specific techniques are presented which exploit object-oriented design principles to reduce the amount of work required in the testing process. The goal is to generate the minimal number of test cases and to execute the minimal number of cases at each level of testing. This tutorial’s objective is to prepare attendees to effectively use a formal testing process in developing object-oriented applications. Upon completion of this tutorial attendees will be able to: Understand the problems unique to testing object-oriented software Design classes that are more easily testable Create both static and dynamic test cases for object-oriented software Effectively use the Hierarchical Incremental Testing method Structure development and test teams more effectively Presentation Format: Lecture Attendee Background: This tutorial is directed toward anyone who is interested in testing objects. 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 developed custom testing processes for a variety of companies. 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.

Design is as much an art as it is a science. To practice the “art of design,” you need creativity, balanced with tools and techniques, just like an artist. What is a “good” design and what is a “bad” design? “Good” and “bad” are both relative terms – they imply a median and tools or criteria with which to measure. This intermediate level tutorial seeks to give attendees insight into the art and science of OO design. Using a group workshop approach, we develop phases of a design problem. At various stages, we analyze results and discuss the tradeoffs and issues raised. We explore design principles and patterns in an appropriate context and work through the actual designs, highlighting decisions taken and influencing factors. This is a fast-paced learning experience. The objective is to actively participate in a compressed OO design process and gain appropriate tools and techniques to leverage in your own design work. This tutorial is fun to attend and will hone your design and teaming abilities. Presentation Format: The tutorial is presented as a series of interactive workshops. Attendees work in groups with feedback sessions following each workshop. Appropriate material is presented on a just-in-time basis. Attendee Background: This tutorial is aimed at architects, designers and developers moving into or interested in object-oriented design. Basic understanding of the UML is required. Nigel Bakker is a Senior Consultant at CCH Software Development in the area of object-oriented application development. He has had many years of software development experience applying object technology in applications ranging from banking systems to embedded controller and communication systems. He has designed and built systems in C++, Java, and other languages. In his role as a Consultant and Mentor he often writes and presents training in various areas related to object technology. He also enjoys writing about object technology and has published several articles in South African publications, including the online publication ITWeb. Christopher Nel is a software-development consultant with CCH in the area of OO. He works with customers to create ‘high quality software that leverages competitive advantage’ and has over a decade of relevant experience. Nigel and Chris present their work locally and internationally and are both part-time lecturers.

When developers build large-scale industrial software systems they have to cope with network environments. Middleware technologies such as CORBA help to master the complexity of inter-process communication. However, an object-oriented remote method invocation paradigm alone is insufficient for building sophisticated distributed software systems. We also need services such as transactions, persistence, and security. Thus, developers typically spend more than 50% of their time integrating these services instead of focusing on application logic. Wouldn’t it be better if the middleware infrastructure could integrate all of these services for us? This is exactly what server technologies such as Enterprise JavaBeans, CORBA Components, and COM+ provide. The goal of this tutorial is to present, compare, and interweave technologies for middle tier components. In its first part, the tutorial will introduce fundamental concepts behind server component technologies using patterns. In the second part, we will introduce and compare the technologies themselves. The main focus of the third part is design principles for how to efficiently leverage these component technologies. Attendees will get a detailed overview of the main principles of server component technologies. The tutorial will enable them to compare, evaluate, and leverage technologies such as CORBA Components, COM+, and EJB. Presentation Format: Lecture. Attendee Background: Attendees should be familiar with Distributed Object Computing infrastructures, e.g., CORBA, COM, or RMI. Sound knowledge of object-oriented programming is required. Michael Stal is head of the Distributed Object and Component Computing group at Siemens Corporate Technology. He is co-author of the book “Pattern-Oriented-Software Architecture - A System of Patterns” as well as of “POSA2- Patterns for Distributed and Concurrent Objects” (to appear at OOPSLA 2000). Michael represents Siemens at the OMG. He is editor-in-chief of the German magazine Java Spektrum, and president of the International Java Club.

After a decade of OO projects, what have we learned? Develop in increments to form a habit of delivering; make sure you have a decent executive sponsor, project manager, and technical leader; get training; and don’t forget the lessons of the last four decades. This tutorial walks through appropriate expectations, project setup, technology selection, domain modeling, with increments and iterations, prototypitis and the death spiral, setting up teams, handling training, expanding, project management patterns, and advice from hindsight. It includes over 60 specific strategies, truths, fixes and recommendations. The tutorial is liberally sprinkled with case histories and insights from the participants themselves. It overlaps heavily with the book “Surviving Object Oriented Projects.” Presentation Format: Lecture. Attendee Background: Anyone wanting to learn ways to get their OO project out of the mire, or wanting to avoid the mire in the first place. Neither being an OO novice or an OO expert will interfere with the tutorial. The only requirement is an interest in what makes a project work well. Alistair Cockburn, founder of Humans and Technology, was special advisor to the Central Bank of Norway and designed the OO methodology for the IBM Consulting Group in the mid-1990s. His “Surviving OO Projects” was published in 1998. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair’s workshops and tutorials can be found at http://members.aol.com/acockburn.

Most experts in object-oriented development stress the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky, that code base is structured just right to support the new function. Of course most of the time we are not lucky and, often, new functionality is just patched on top. Soon this patch upon patch approach causes the design to decay, slowing down later progress and breeding bugs. Refactoring is all about how you can avoid these problems by modifying your code in a controlled manner. Done well you can make far-reaching changes to an existing system quickly, and without introducing new bugs. With refactoring as part of your development process you can keep your design clean, make it hard for bugs to breed. and keeping your productivity high. The main aim of this tutorial is to understand the basic principles and rhythm of refactoring. We’ll also cover a dozen or so important refactorings and the “code smells” that lead you to refactoring. Presentation Format: Presentation. Attendee Background: All the examples will use Java so you should have a working knowledge of Java. Martin Fowler has spent over a decade applying object technology to business information systems. He is the Chief Scientist for ThoughtWorks, an Internet professional services firm. He has worked on projects for leasing, payroll, derivatives trading, and health care with a wide range of technologies. His clients have included Chrysler, Dana Commercial Credit, Andersen Consulting, and IBM. He is the author of the Addison-Wesley books “Analysis Patterns,” “UML Distilled,” and “Refactoring.”

XML is becoming the standard for exchanging information between business partners. For example, you might create an XML application to order new material from a supplier, and write a generator that puts the order data into an XML document according to the supplier’s DTD. And it works quite well. But, now you must also support another supplier – with a completely different DTD. How? This is exactly the scenario where meta-information becomes useful. Meta-information and reflection allow you to add new application classes at run-time. This tutorial introduces an approach in C++ to configure the processing of new DTDs at runtime, without any changes to the program’s source code. That approach is based on the techniques presented in the tutorial “Metaclasses in C++” (#22). It also presents some general techniques to handle XML using C++. Participants will acquire a thorough understanding of the potential of C++ to master the challenges of modern XML applications. Presentation Format: Lecture. Attendee Background: This tutorial builds on the approach presented in “Meta-Classes in C++” and requires therefore that participants have attended that tutorial as well (or have acquired similar knowledge elsewhere). General knowledge about XML and DTDs is helpful. Detlef Vollmann has a background of 15 years in software engineering and more than 10 years with object technology. As an independent consultant he supports several Swiss companies with the design of object-oriented systems. Since 1991 he has authored and taught courses in C++, Object-Oriented Technologies, Software Architecture, and Distributed Computing for Swiss Digicomp AG.

Microsoft’s Windows DNA technology framework is built upon Microsoft COM+ (Component Object Model). COM+ is the basic glue that is able to transparently connect different islands of code, for example, the different tiers in a multi-tier software system. Since COM/COM+ is available in every Windows-based operating system, it is the infrastructure of choice for building distributed component-based applications in a pure Win32 environment. The goal of this tutorial is to provide a detailed overview of Microsoft COM/COM+ for C++ developers. The tutorial will be presented in three parts. The first part covers the architecture behind Microsoft COM/COM+. The second part illustrates all constituents of COM using C++ examples. The last part covers advanced services such as MSMQ or MTS. Attendees will learn how to leverage COM/COM+ for their own applications. Presentation Format: Lecture with small example demonstrations. Attendee Background: Attendees should be familiar with object-orientation and C++. They should also have some experience in programming Win32 applications. Michael Stal is head of the Distributed Object and Component Computing group at Siemens Corporate Technology. He is co-author of the book “Pattern-Oriented-Software Architecture - A System of Patterns” as well as of “POSA2- Patterns for Distributed and Concurrent Objects” (to appear at OOPSLA 2000). Michael represents Siemens at the OMG. He is editor-in-chief of the German magazine Java Spektrum, and president of the International Java Club.

Enterprise-quality Web applications have their unique requirements: they have a short life span, change is constant but schedules are aggressive, loads can vary greatly but performance is paramount, the network is unreliable and unsafe but security and reliability are imperative. This tutorial describes our own practices and experiences in developing Web applications using Java Servlets. We will present specific descriptions of these requirements and the problems, and provide particular solutions using Java. Participants will become familiar with some of the critical requirements of Web applications and they will acquire the knowledge to construct essential building blocks of successful Java Servlet frameworks. Presentation Format: This tutorial will be based on presentation of “best-practices:” each section will start with a description of the problem, followed by a description of solutions. Where appropriate, the presentation will be enhanced by source code examples and working system demonstrations. Attendee Background: This tutorial is intended for participants who would like to understand some of the issues and solutions in building Java Servlet based Web applications. Familiarity with object-oriented concepts, design-patterns, Java programming, and Servlets will be very beneficial. Naci Dai is a Managing Director for The Object People, a world-leading e-solutions company. He teaches object technology, design-patterns, and distributed computing. He leads and mentors Web development projects for Fortune 500 companies. He has developed the distributed computing curriculum and services for The Object People. He has a background in applied-engineering and computational physics. He received his Ph.D. from Carleton University. Michael Ellis is the Director of e-solutions for The Object People. He teaches object technology and J2EE application development. He leads and mentors Web development projects for Fortune 500 companies. He is the lead architect of a Web application framework that has been evolving within The Object People for over two years. He received his M.Sc. from the University of Guelph.

Management of heap memory is well supported in Java, thanks to the garbage collector. Memory, however, is not the only resource that needs to be managed in a Java program. In this tutorial we explore how Java supports management of resources other than heap memory. The most common problem with resource management is improper release of acquired resources. The Java language offers a number of language constructs for cleanup activities such as resource release – namely finalizers, the finally clause, and reference objects. Closer examination of these mechanisms reveals that the amount of control provided over resource release is limited and might be unsatisfactory if reliable resource release is of paramount importance. We will see that there is no guarantee that a finalizer will ever be invoked, we will talk about unwanted references and why they are a problem, and we will explore whether and how soft, weak, and phantom references mitigate the problems. Presentation Format: Lecture with questions and discussions. Attendee Background: Participants must be familiar with the basic concepts of the Java programming language. Those attendants with a serious interest in high-quality software will get most out of the tutorial. Angelika Langer is a freelance trainer/consultant working and teaching in the area of object-oriented software development in C++ and Java. She is co-author of the book “Standard C++ IOStreams and Locales” released in January 2000 and co-author of a column in C++ Report since 1997. Her teaching is backed by 12+ years of software development in the IT industry, including 5 years of compiler construction and involvement in C++ library development as well as the standardization of C++. She is currently working on a book about advanced Java programming idioms.

Business rules change everyday in the face of rapidly volatile business requirements. How do we handle this change while keeping our systems maintainable, reusable, and extensible? How do we model and handle (represent) rules, for greater reuse and maintainability (and performance)? Business rules are expected to change more frequently than the rest of the business objects. Rules are frequently implemented within the context of the methods of a business object. They refer to other business objects from within a business object’s methods, creating a web of dependencies that are typically implicit. Thus, changing one business rule impacts the set of objects that are dependent upon that rule. This tutorial explores a pattern language for the design and implementation of business rules in object-oriented systems. Practical step-by-step methods to build robust, flexible, and pluggable business rules are demonstrated. The objective of this tutorial is to familiarize participants with best-practices specified in a pattern language for designing and building scalable and adaptable business rules. It also covers a methodology for harvesting business rules locked within legacy systems, integrating them into a component-based architecture, and utilizing the Rule Object pattern language to build pluggable and composable business systems. Presentation Format: This tutorial will be 70% lecture and 30% exercises. Attendee Background: Experience in application development Ali Arsanjani is a Consulting I/T Architect at IBM Global Services’ Enterprise Java Services National Practice, with over 17 years industry experience. He specializes in creating mission-critical architectures for distributed object systems. His areas of research and practice include distributed software architectures, design and domain patterns, and component-based development.

Now that agents are just beginning to become an accepted method to package the working software elements of a business, it’s time to consider what the future holds for business systems that are completely built out of agents. This tutorial explores the future in which agents become autonomous, adaptive, mobile entities inside the business networks of an enterprise - where the agents can be software, machines, and/or people. It focuses on the potential power (and complications) of design in a multi-agent setting, and introduces participants to ways of thinking beyond individual, isolated software agents to consider entire systems of interacting agents that adapt and evolve. The tutorial surveys a wide range of agent-based systems, both natural and artificial, that are being studied within the field of Complex Adaptive Systems (CAS), and considers the lessons they offer for the engineering of autonomous object systems. Participants will be encouraged to think about agents in new ways by incorporating the science and research directions of complex adaptive systems. In particular, recent results from studies of multi-agent dynamics and emergent phenomena will be discussed. Presentation Format: Lecture 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 object-oriented and agent-based approaches. Throughout most of his 30-year career, he has been heavily involved in developing better methods to manage, understand, and express business system requirements. Now, he is one of the first practical implementers of object and agent modeling, and implementation – consulting to major companies worldwide. He is a very experienced and highly-regarded educator and speaker. James Odell is also the co-chair of OMG’s Agent Work Group and Analysis and Design Task Force. William Tozier is a technical consultant and advisor specializing in engineering projects involving complex adaptive systems. Originally trained as a molecular and cell biologist, he has spent the last nine years working as an academic and professional researcher. His recent work includes genetic programming and other evolutionary optimization methods applied in diverse engineering fields, coevolutionary dynamics, theoretical biochemistry and protein folding, novel methods for drug lead compound discovery in the pharmaceutical industry, bioinformatics, and studies of the origin of life.

The desire to build “90% COTS” solutions is growing. Unfortunately, component-based systems with plug-and-play interoperability can be impeded by millions of lines (and dollars) in legacy software. Enterprise Application Integration is arguably the most important, most difficult, and least developed aspect of modern systems development. Because the enabling technologies are still under-developed, engineering discipline remains the best tool for controlling and limiting problematic dependencies. Luckily, techniques for developing highly pliable enterprise architectures are becoming available. This tutorial covers the architectural goals best suited for enterprise systems integration, outlines the challenges and barriers to achieving those goals, and provides in-depth techniques for addressing the challenges. The focus is on the “semantic” issues behind software system interoperability. Also discussed are current industry enabling technologies, future technologies, lessons-learned, and pitfalls common with EAI projects. Upon completion of the tutorial, attendees will understand the important goals and related challenges that drive application integration architectures. Attendees will be able to assess a project’s semantic needs for interoperability and will be given techniques for deciding which technologies and architectural approaches are best suited. Presentation Format: Lecture and Guided Discovery. Attendee Background: Knowledge of OO and software architecture Scott Pringle is a Senior Software Architect and System Architect for Lockheed Martin Mission Systems in Gaithersburg, MD. As a member of the Software Technology and Architecture Center he provides expertise to programs and proposals in the areas of System and Software Architecture, Object-Oriented Analysis, Design, and Implementation. Scott consults with projects of varying sizes (from 8 to 300 engineers) across Lockheed Martin. In addition, Scott prepares and presents training material in the areas of Software Architecture and Object-Oriented Technologies. Scott has developed and delivered Lockheed Martin Workshops on Design By Contract, Association Implementation, Executable Framework Development, Object-Oriented Essentials, Designing Interfaces, and Dependency Analysis. Thad Scheer is a Senior Software Architect and OO Mentor for Blueprint Technologies Inc., a premier software architecture company. He has worked both on and off the critical path for over a dozen projects of all sizes in multiple domains. Thad is an expert at applying OO towards achieving high degrees of productivity and quality. Thad is also an instructor with Learning Tree International where he teaches OOA/D, UML, and Advanced C++.

Over the last couple of years Software Patterns have become one of the most important areas for software development. Instead of describing abstract techniques to build software, they highlight useful examples that can be adapted and used again by developers. Although best known for object-oriented design, patterns are also a valuable technique for analysis. This tutorial looks at a selection of the patterns Martin Fowler has collected and published in his book “Analysis Patterns: Reusable Object Models.” The tutorial selects two areas: it first outlines patterns discovered in health care which were then used for corporate financial analysis – a prime example of how pattern reuse can cross traditional vertical domains. It then moves to accounting, showing how a financial system can be built as a network of accounts and posting rules that contain the rules for transferring the amounts between the accounts. Presentation Format: Lecture. Attendee Background: Attendees should have a working knowledge of OO analysis and design using the UML. Martin Fowler has spent over a decade applying object technology to business information systems. He is the Chief Scientist for ThoughtWorks, an Internet professional services firm. He has worked on projects for leasing, payroll, derivatives trading and health care with a wide range of technologies. His clients have included Chrysler, Dana Commercial Credit, Andersen Consulting, and IBM. He is the author of the Addison-Wesley books “UML Distilled,” “Refactoring,” and “Analysis Patterns.”

Getting software developers to perform unit testing adequately is challenging. The Java language has some interesting features that make it possible to automate much of this task and even add an element of fun to it. This intermediate level tutorial provides an in-depth look at three different, but complementary, approaches to unit testing in Java using harnesses and frameworks. Java’s Reflection API and XML are both technologies that can be used by unit test frameworks. We show how they can be exploited to simplify and enable automated unit testing. Presentation Format: A combination of lecture and workshop styles places the emphasis on learning through exploration, which allows attendees to put theory into practice. Attendee Background: A working knowledge of Java is essential. Some experience with object modeling would be useful since many of the design elements are presented using the UML. The material is intended for developers and architects who would like to improve the quality of testing in their development processes. Nigel Bakker is a Senior Consultant at CCH Software Development in the area of Object Oriented Application Development. He has had many years of software development experience applying Object Technology in applications ranging from banking systems to embedded controller and communication systems. He has designed and built systems in C++, Java and other languages. In his role as a Consultant and Mentor he often writes and presents training in various areas related to Object Technology. He also enjoys writing about Object Technology and has published several articles in South African publications, including the online publication ITWeb. Christopher Nel is a software-development consultant with CCH in the area of OO. He works with customers to create ‘high quality software that leverages competitive advantage’ and has over a decade of relevant experience. Nigel and Chris present their work locally and internationally and are both part-time lecturers.

As professional software practitioners, we dwell in a constantly changing industry, in which new APIs, languages, and technologies emerge almost every week. To keep up, people attend classes or conferences each year, but this does not adequately prepare them for all of the changes. Study Groups provide a real solution to this problem. They are places where people have dialogues on important and complex subjects on a weekly or bi-weekly basis throughout the year. Study Groups encourage people to help each other learn, and do so in a fun and economical way. This tutorial teaches people how to create and run their own Study Groups. We will review 21 patterns from “Pools of Insight: A Pattern Language for Study Groups.” Subjects covered include the Spirit of a Study Group, Atmosphere, Roles, and Customs. The tutorial culminates in a simulation of a Study Group. Presentation Format: Lecture and group simulation. Attendee Background: Anyone in the software business will find this tutorial useful. Joshua Kerievsky is founder of and principle consultant for Industrial Logic, Inc. (http://industriallogic.com). He founded the first public patterns Study Group in 1995, was Conference Chair of Using Patterns ‘97, designed and actively teaches the Design Patterns Workshop (http://industriallogic.com/training/ili_dpclass.html) and the online Programming with Patterns workshops (http://industriallogic.com/training/pwp.html). He was educated at St. John’s College, which follows the Study Group model for every class for 4 years.

This tutorial will describe a process for developing frameworks. The process is driven by examples, which are used both to design a new framework and to document it when it is finished. The tutorial shows how to use refactoring and design patterns to make frameworks flexible. It will teach how to choose examples, how to manage iteration, and will discuss the problems involved in making frameworks cost-effective. Participants will learn the overall process of building frameworks as well as when not to build a framework. They will also learn how to avoid the biggest errors. Presentation Format: Lecture. Attendee Background: Attendees should know what a framework is and should have used at least one framework. This implies at least a year or two of object-oriented programming experience. Ralph Johnson has been practicing object-oriented programming since 1985, when he joined the faculty at the University of Illinois. He has been to every OOPSLA. He has been involved in the development of frameworks for operating systems, compilers, drawing editors, music synthesis systems, accounting, billing and insurance. He is one of the co-authors of “Design Patterns.” Ralph’s home page may be found at: http://st-www.cs.uiuc.edu/users/johnson.

How much testing is enough? Too little? Too much? What do developers need to test? The available eXtreme Programming literature differentiates between unit testing and functional testing, and gives unit testing during development a (well-deserved and much-needed) high priority, but fails to address a number of other important aspects of developer testing: GUI testing, performance testing, and packaging/delivery testing, for example. This tutorial will illustrate new techniques such as implementing “skins” for SUnit, defining test resources for managing items which remain active over a series of tests (e.g., database connections), and automating or integrating various other tests into SUnit. Participants will discover a number of new and alternative solutions for testing problems that have not yet been adequately addressed in either the XP literature or tools, along with working implementations of these techniques. Presentation Format: The tutorial will be only partly lecture-based. Participants are encouraged to present problems (and possible solutions) encountered in their work, which the group will address and attempt to solve. Attendee Background: Participants should have some experience in both Smalltalk and eXtreme Programming. Joseph Pelrine is an expert Smalltalk programmer with over 11 years extensive OT experience and has worked with Kent Beck, the originator of XP, for a number of years. A former columnist for the Smalltalk Report and noted international speaker, he is currently a senior consultant with Daedalos Consulting in Switzerland. He is co-author of the forthcoming book, “Mastering ENVY/Developer,” due for publication from Cambridge University Press in fall, 2000.

Design by Contract involves using assertions (preconditions, postconditions, and invariants) to help designers document, reason about, and check properties of their software artifacts. By building up examples in Eiffel and Java, the tutorial will introduce a method for designing contracts, based on a set of principles and guidelines for their effective use. Attendees will learn a set of principles and guidelines they can use to rigorously specify their class designs and hence achieve better designs, clearer documentation, and easier verification. Presentation Format: The presenters will work through a series of carefully selected examples, building up hand-written slides on the way. These will be made available to attendees after OOPSLA via the Web, together with notes to remind attendees of the significance of the slides. As principles and guidelines emerge, summary slides will be used to support reviewing them. These slides, and prepared solutions to the examples, will form the tutorial notes available in advance. Attendee Background: Attendees should have a good working knowledge of an object-oriented programming language, and a curiosity about how formal documentation can help express a design and check its implementation. No knowledge of mathematical notations is assumed. Jim McKim is Clinical Professor and Chair of the Computer and Information Sciences Department of Rensselaer Polytechnic Institute. He has been teaching, publishing, and consulting in the OO arena for six years, focusing on design by contract. Richard Mitchell has worked with object technology since the late 1980s, in research, teaching, and consultancy. He is now with InferData Corporation, a US training and consulting company. He has used contracts at both the analysis and design levels.

In the object-oriented world, it’s our fate to experiment with new ideas. It started with objects and continued with OMT, Fusion, Objectory, UML, Patterns, eXtreme Programming, and so on. Our community is good at accepting new concepts but are we good at evaluating the results? “You have paid the tuition, now are you going to learn the lessons?” Carefully reviewing an OO project at its end is one of the most obvious ways of improving your software development process and building OO mastery. Sadly, such a review rarely happens – why? Because we don’t know how to do it; we don’t know how to deal with the emotions; we don’t know how to address failure; and we don’t know how to convert the lessons into new practices. In this tutorial, we look at an entire philosophy and methodology to lead an effective review of a significant OO project. Expect to learn a number of tools, techniques, and skill areas necessary to be an accomplished facilitator. Presentation Format: Combination of lecture, exercise, performance of key parts of a retrospective, and group question and answer. Highly interactive. Attendee Background: None. Norm Kerth is an experienced software engineer and researcher focusing on specification and design activities, quality assurance, continuous process improvement, project management, and growing effective teams. He has led nearly 70 retrospectives and has authored a book nearing publication on the topic. Jerry Weinberg has called this book “the definitive work on the topic.” Norm has been a full time consultant since 1984 and helps firms improve their software engineering discipline. He has particular interest in objects, pattern languages, and building high performance teams. Prior to starting his company, Elite Systems, he was a professor at the University of Portland. He has a decade of engineering experience with Tektronix and is a master teacher, with over 30 years of experience in front of students.

Usage-Centered Design is a proven, scalable process for delivering systems closely fitted to the needs of end-users. For effective user interface design, usage-centered design employs Essential Use Cases, a refinement of conventional use cases that casts narratives into a structured form focused on purposes and separating user intentions from system responsibilities. Essential Use Cases guide user interface design more effectively toward ease and efficiency of use, and can integrate user interface development directly into projects using UML and the Unified Process. Participants will learn how structured Essential Use Cases differ from conventional use cases and how they fit into a systematic usage-centered design process for object-oriented software. They will gain practice in deriving Essential Use Case Models, writing structured narratives, and applying them to user interface design problems. Presentation Format: Through discussion, illustrative examples, and hands-on application, this tutorial will introduce techniques for constructing and elaborating User Role Models, deriving Essential Use Case Models, representing them in UML and applying them to realistic user interface design problems. Attendee Background: Participants should have some experience with use cases as employed in object-oriented analysis and design. Familiarity with basic user interface design principles and issues will also be helpful. Dr. James Noble has recently returned home to lecture at the Victoria University of Wellington, New Zealand. James has extensive experience lecturing, teaching, and mentoring with software design, user interface design, and design patterns. Larry Constantine, Professor of Computing Sciences, University of Technology, Sydney, is a pioneer of modern software engineering practice and an internationally recognized authority on the human side of software. He has 10 books and over 125 papers to his credit. Lucy Lockwood, President of Constantine & Lockwood, Ltd., is a highly regarded trainer and consultant and co-author of “Software for Use: A Practical Guide to the Models and Methods of Usage-Centered Design” (Addison-Wesley, 1999).

Memory management can be complex and hard to manage correctly – errors often occur. This tutorial introduces the basic paradigms and techniques of memory management and garbage collection in the context of OO. It aims to help programmers improve their techniques by showing how errors can be avoided; it probes the limits of manual allocation strategies and examines the benefits offered by GC. Examples and hints on how to avoid pitfalls in languages such as C++ are given. C++ programmers experiencing memory management problems will learn what support GC can offer; OO programmers already using GC will obtain a deeper insight into the operation of basic collectors. The tutorial will enable participants to evaluate the benefits and costs of common algorithms, to understand the implications for their code and to make informed choices between collectors – and whether or not to use GC at all. Presentation Format: Presentation based. Attendee Background: The tutorial assumes basic knowledge of object-oriented concepts. Some programming experience with at least one object-oriented programming language or more extensive programming experience with non-object-oriented languages is desirable. However no previous knowledge of garbage collection is required. Richard Jones is a Senior Lecturer and Deputy Director of the Computing Laboratory at the University of Kent. He is the prime author of the only book on this subject: “Garbage Collection: Algorithms for Automatic Dynamic Memory Management” (Wiley 1996). His interests include programming languages and their implementation, storage management, and distributed systems. He is a member of the Steering Committee of the International Symposium on Memory Management and was Programme Chair for ISMM‘98. Eric Jul is an Associate Professor and Head of the distributed systems group at DIKU, the Dept. of Computer Science, University of Copenhagen. He is co-designer and principal implementor of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support including distributed storage management and object-oriented design and analysis. He was Programme Chair for ECOOP‘98.

Much has been written about component-based design but most books and articles deal in generalizations and possibilities, rather than providing explicit and clear guidance. This tutorial will follow a small case study through from requirements capture to code-ready specifications, and will set out the full client and server architectures needed to make it work. The modeling and specification techniques used will follow the UML, with the target technologies being EJB or COM+. A Web-based UI is assumed. As a result of the tutorial students will know and understand: A simple process for component-based design. How to use UML to specify components. How components built with EJB or COM+ fit into application architectures. Presentation Format: Presentation by instructor with frequent opportunities for questions from the audience and two short exercises to reinforce key points. Attendee Background: The tutorial is aimed at modelers, system designers, and architects. A working knowledge of UML is required, and some understanding of EJB or COM+ would be an advantage. John Daniels is a consultant at Syntropy, Ltd., providing help with system architectures and development processes to a number of large corporations. He was previously Application and Technical Architect for Bankers Trust in London, and before that Managing Director of pioneering consulting and training company Object Designers Limited. He has applied object technology in a range of industrial and commercial applications since 1985. He has given tutorials at many object technology conferences, has prepared and delivered many training courses, and has published extensively.

Originally, templates were introduced to the language in order to express common structure in the form of parameterized types implemented as class templates. Function templates, in addition, allow expression of common functionality. Using the template language feature in C++, behavioral patterns as defined by Gamma et al. can be implemented using templates instead of inheritance and virtual functions. Often, classic object-oriented runtime polymorphism can be replaced by compile-time polymorphism, the effect of which is a considerable gain in runtime performance. In this tutorial, the alternative template technique is demonstrated using the Strategy pattern as an example of a behavioral pattern and the Interpreter pattern as an example of a structural pattern. The latter will serve as an introduction into template meta-programming and expression template libraries. Presentation Format: Presentation. Attendee Background: Participants must be familiar with C++. Basic familiarity with C++ template programming and design patterns will help. Angelika Langer is a freelance trainer/consultant working and teaching in the area of object-oriented software development in C++ and Java. She is co-author of the book “Standard C++ IOStreams and Locales” released in January 2000, and co-author of a column in C++ Report since 1997. Her teaching is backed by 12+ years of software development in the IT industry, including 5 years of compiler construction and involvement in C++ library development as well as the standardization of C++. She is currently working on a book about advanced Java programming idioms.

With the popularity of refactoring and eXtreme Programming, more programmers have come to accept that testing is one route to higher productivity. This tutorial will teach three economical methods of test design: Techniques that search for boundary and logical condition errors - these are simple extensions of what most programmers already do. Catalog testing, which is based on the notion that programming clichés bring with them clichéd errors. Method interface testing, which searches for errors when calling methods (especially inherited or overridden methods). Test design is about bug-finding power. Test implementation is about not wasting time. We will discuss picking the right testing interface and choosing which tests deserve to be run more than once. After the tutorial, attendees will be able to apply three test design methods. They will also be able to articulate the economic tradeoffs of test implementation and automation. Presentation Format: Format will be lecture combined with short labs. Attendee Background: Attendees should be experienced programmers. No testing background is required. Examples will be in C++ or Java, but familiarity with any object-oriented language should suffice to understand them. Brian Marick worked for 11 years as a tester, developer, and line manager, mostly on operating systems and compilers. Joint research at the University of Illinois led to internal consulting and then, in 1992, to his own consulting business, TestingFoundations. Because practitioners are justifiably suspicious of those who talk about software development but never actually do any, he tries to spend half his time building, testing, and maintaining tools, some freely available. He is the author of “The Craft of Software Testing” (Prentice Hall, 1995) and the freeware code coverage tool (http://www.testing.com/tools.html). He was the first technical editor for Software Testing and Quality Engineering magazine and is now a contributing editor. His Web site may be found at: http://www.testing.com.

Most software developers think a thorough knowledge of the Java programming language and its numerous APIs is the key to developing good Java software. This is often done at the expense of understanding and applying solid object technique. Participants in this tutorial will discuss the most common object design mistakes I have seen in working with over 200 designers in the past seven years. We will analyze the source of the mistakes, work to understand object principles to help these mistakes, and apply the newly understood principles to example problems. Presentation Format: Presentation. Attendee Background: Java software developers of all levels of expertise. Todd Lauinger has over 10 years of experience developing mission-critical large-scale software systems in a variety of technologies and techniques. He is a published author and experienced conference speaker, teacher, and mentor in state-of-the-art software development strategies.

Use cases describe the behavior of a software system from an external usage perspective. There is an art to writing them clearly. Written carefully, use cases convey key usage specifications and can be tied to other requirements. Written poorly, use cases are confusing and ambiguous. This tutorial presents examples of good and bad use case descriptions drawn from real projects, and practical techniques for writing three forms of descriptions: narratives, scenarios, and conversations. Narratives are high-level descriptions written from an external perspective. We show how to elaborate these high-level descriptions, choosing either a scenario form, which emphasizes sequence, or a conversation, which highlights interactions between a user and the system. Tips for naming use cases, describing policies, errors and exceptions, attaching other important information, and writing glossary entries are also presented. This is a hands-on tutorial. Attendees will practice writing, critically reading of, and revising use cases in various forms. After this tutorial, participants will be able to apply principles and writing techniques to their own projects, writing appropriate usage descriptions. Presentation Format: Slides, lecture, short writing and reviewing exercises followed by comment and suggested solution(s). Attendee Background: Students should be looking for practical ways to improve their writing. They should be familiar with writing and reading software requirements and usage descriptions. Since Use Cases are part of the Unified Modeling Language (UML), students could benefit from an introduction to object concepts. However, an object background is not a prerequisite! Rebecca Wirfs-Brock is president of Wirfs-Brock Associates, a firm specializing in the transfer of object analysis and design expertise to organizations and individuals through training, mentoring, and consulting. She spent 17 years as a Software Engineer at Tektronix, leading the development of Color Smalltalk. She has written articles, lectured, and presented tutorials on object analysis, design, and management topics, and has been an innovator in object technology since 1984. Recently, she has authored use cases for a telecommunications framework and an online banking system. She practices what she teaches! Rebecca is co-inventor of the Responsibility-Driven Design method and co-author of the classic, “Designing Object-Oriented Software.” John Schwartz, Vice President at Wirfs-Brock Associates, has devoted his career to specifying and building complex software systems. Before joining Wirfs-Brock Associates, John was Vice President of Information Technology at GST. There, he led the development of an object-oriented framework that integrated back office systems. John was a charter member of the initial OMG object task force, and pioneered the application of the Object Behavior Analysis method, while at ParcPlace. As an experienced analyst, software developer, consultant, and IT manager, John has lived in the trenches. He knows the problems people encounter when trying to convey requirements to a diverse audience and is constantly working on ways to improve technical communications.

Separation of concerns in object-oriented software has not achieved its anticipated benefits—reduced complexity, improved reusability, and simpler, non-invasive evolution. Instead, problems associated with poor separation of concerns are rife: conceptually simple, localized evolution requires pervasive, invasive changes; failure to anticipate future needs often necessitates a major re-architecture effort, while building in extra flexibility complicates the software; and reuse is difficult. A key to improving this situation is multi-dimensional separation of concerns (MDSOC): the ability to encapsulate multiple kinds of overlapping and interacting concerns, such as features, variants, roles, and aspects, and to work with whichever are most appropriate for a given activity. This tutorial describes how to accomplish MDSOC with Hyper/J™, a tool available for free download, in the context of standard Java™ development. Participants will learn the principles, benefits, and details of MDSOC using Hyper/J™. The focus is on addressing some real, pervasive problems in participants’ own Java™ development, especially in the areas of evolution, integration, reuse, and (re)use of design patterns. Presentation Format: The tutorial combines presentation with interactive exploration of examples. Participants will have the opportunity to select examples from a prepared set, and to contribute their own. Attendee Background: Attendees must have experience developing object-oriented applications, and some familiarity with Java. Peri Tarr is a researcher at the IBM T. J. Watson Research Center. She co-invented hyperspaces, leads the Hyper/J™ tool development effort, and has been exploring issues in multi-dimensional software engineering throughout the software lifecycle. She has co-presented tutorials on subject-oriented programming and co-organized workshops on multi-dimensional separation of concerns at several conferences Harold Ossher is a researcher at the IBM T. J. Watson Research Center. He co-invented subject-oriented programming and hyperspaces, and manages a group that conducts research and technology transfer in these and related areas. He has co-presented tutorials on subject-oriented programming and co-organized workshops on subjectivity in object-oriented systems and on multi-dimensional separation of concerns at several conferences.

For developing simple client-server applications, VisualAge provides a visual language for generating the mappings of GUIs to database values and domain objects. For complex applications, tools such as Top-Link 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 some of the design patterns used in such tools as VisualAge and TopLink when mapping objects to relational databases. This knowledge will enable attendees to not only successfully apply persistence to their objects, but also to understand problems that might arise while using tools that assist with the mapping process. Presentation Format: Slides will be presented along with a working example of the framework. Attendee Background: 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. Joseph W. Yoder has been studying and developing software since 1985. Since 1990, his focus has been on object-oriented technology. He has developed frameworks, helped design several applications, and mentored many new developers. For the last few years, Joe has been investigating “visual languages for business modeling” and “active object-models.” 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. This has included how to evolve more reusable fine-grained components from frameworks and the study on how to manage or promote reuse through component libraries.

Learn to identify and diagnose the components of your organization’s methodology, and learn ways to make it more effective. 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 basic elements of a methodology. Several examples of effective, lightweight, and real methodologies are given, along with commentary on the social setting for each. The tutorial examines the conditions suited to shifting from a lighter to a heavier methodology and the penalty for doing so. The tutorial ends with the presentation of a small family of lightweight and practical methodologies, including eXtreme Programming, which are optimized for productivity, making maximum use of human, face-to-face communication. Considerations about success and failure in affecting culture are visited again at the end. Presentation Format: Lecture plus open discussion. Attendee Background: Experienced developers, team leaders, methodologists, and technology selectors trying to choose, design, or tune a methodology for their organization. Should have significant software team experience, preferably but not necessarily OO. Must have used at least one methodology and thought about others. Alistair Cockburn, founder of Humans and Technology, was special advisor to the Central Bank of Norway for object technology and software project management, and the OO methodology designer for the IBM Consulting Group. His book “Surviving OO Projects,” was published in 1998, and “Writing Effective Use Cases” in 2000. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair’s workshops can be found at http://members.aol.com/acockburn.

This tutorial presents the issues facing modern high-performance garbage collectors and examines the approaches taken by state of the art garbage collectors. Participants will gain a deeper insight into the operation of modern, high performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of such garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors. Presentation Format: This tutorial will be presentation-based. Attendee Background: Participants will be experienced programmers familiar with basic GC technology (for example having attended the “Introduction to Memory Management and Garbage Collection” tutorial). Basic knowledge of OO implementation is useful. Richard Jones is a Senior Lecturer and Deputy Director of the Computing Laboratory at the University of Kent. He is the prime author of the book on Garbage Collection. His interests include programming languages and their implementation, storage management and distributed systems. He is a member of the Steering Committee of the International Symposium on Memory Management and was Programme Chair for ISMM‘98. Eric Jul is an Associate Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he leads research in distributed, heterogeneous computing. He is co-designer and principal implementor of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPLSA conferences he has run a number of workshops and tutorials related to distributed computing. He was Programme Chair for ECOOP‘98.

One company can develop printers more quickly and with more innovative features using a fraction of the staff of its competition. They do this with an architected, reuse-based approach. For every such success story, there is one of failure: the project is under-resourced or cancelled; it is stalled with infighting or lack of leadership; developers dislike or act resistively to the architecture; etc. We have turned what we have learned from these successes and failures into a set of Software Architecture Action Guides. In this tutorial, we present our Action Guide approach to software architecting. Action Guides are short (fit on an index card) and designed to solve a specific problem (e.g., develop an architectural vision, capture non-functional requirements, document interfaces). Taken together, they provide a comprehensive architecting process that uses UML as the modeling language. Used selectively, teams can tailor their own lightweight architecting method. Used individually, they produce some key result for the architecting team. Attendees will: gain an understanding of the architecting process. use Guides in exercises, learning a specific architecting technique (e.g., creating a communication plan, creating architecture principles). gain experience with the Action Guide approach. Presentation Format: Stories, large-group graphical facilitation and small team exercises Attendee Background: Practicing architects and senior developers. Dana Bredemeyer has been giving presentations on software architecture and teaching software architecture workshops at Hewlett-Packard and elsewhere for 5 years. He has over 20 years experience architecting, designing, and developing software systems, including 16 years with HP. He has provided architecture consulting and training to architects, architecture teams, and their management, and has helped teams develop software, firmware, and system architectures. Dana Bredemeyer and Ruth Malan are writing a book titled “Software Architecture Action Guide” for Prentice-Hall. Ruth Malan has authored numerous papers and book chapters on object-oriented development, reuse and architecture. She is editor and an author of the book, “Object-Oriented Development at Work: Fusion in the Real World.” She has extensive experience teaching and consulting in software architecture, having helped pioneer the architecture consulting and training program while at Hewlett-Packard. Dana and Ruth are editors of the highly popular “Resources for Software Architects” Web site (http://www.bredemeyer.com).

Most system analysis and design books have a shortcoming: they focus on analysis of the old system and documenting and implementing the new, but they give little attention to the creativity needed during conceptual design. Design is still treated as largely a matter of bringing a group of intelligent, creative people together and waiting for the magic to happen. This magic remains unexplained, largely unexplored, and, to a large extent, ignored. This tutorial adds creative, analytic, and synthetic tools to the developer’s tool-kit. The participants gain better insight about when to use which supporting method. Presentation Format: The tutorial will introduce techniques during short presentations. After each set of techniques, participants will discuss the applicability in development practice (using evaluation techniques and what was learned). The techniques are applied in exercises and a running case. Each part will take 1/3 of the time. Attendee Background: Managers, developers, and everybody who wants to gain experience in the use of creative tools during the development process. Martine Devos is Solutions Architect, Marketing and Portfolio, for EDS EMEA. She provides consultancy and training on organizing for reuse, and coordinates a research project on product line development. As IS manager at Argo she initiated and coordinated the development of a framework for administrations and several applications using it. Her main focus is on the use of IS – and “softer software” – to support change programs and learning. This got her the title of ICT-manager of the year. She participated in, and organized, several workshops, panels, and tutorials at OOPSLA, ECOOP, OT, and TOOLS. She is Program Chair of EuroPlop 2000.

This tutorial has a worthy goal: together, the presenter and the attendees will implement a generic smart pointer, a highly functional piece of code that sports configurable behaviors and an amazing rate of reuse. Smart pointers are hard to get right. But because they nicely automate things that are hard to manage by hand, smart pointers are an essential ingredient of robust C++ applications. As small as they are, smart pointers can make the difference between failure and success. The implementation presented uses a new class design technique - Policy Classes. Policy Classes are specialized structural and behavioral entities that decide one well-defined aspect of a complex behavior. The advantage of Policy Classes is that they can be combined freely in concrete classes, thus leading to combinatorial reuse. Through only six mixable-and-matchable policy classes, SmartPtr achieves about 160 different predefined behaviors. Clients can define their own policies. Participants will learn new C++ idioms for improving code reuse, and how to dovetail generic and object-oriented programming techniques in class design. Presentation Format: A highly interactive presentation, garnished with questions and whiteboard examples. Attendee Background: Attendees are advanced C++ programmers and system architects. Minimal C++ template knowledge is assumed. Andrei Alexandrescu is Development Manager with RealNetworks, Inc. He is a columnist for C++ Report, a former contributor to C/C++ Users Journal, and the author of the upcoming book “Design with C++” (tentative title), Addison Wesley Longman, Reading, MA. Andrei holds an MS degree in Electronics from the Polytechnic University of Bucharest.

Interactions between objects are too often coded in the way messages are exchanged and methods are called, making it difficult to understand and evolve the way components are interconnected without a deeper analysis of the way objects are designed. Yet, most businesses require high levels of reconfigurability of existing services, which suggests that an explicit model of the coordination that is required between system components should be given immediately during domain modeling. Capitalizing on work in Software Architectures and Coordination Languages, and our experience in the banking industry, this tutorial puts forward the concept of contracts for providing explicit representations of interconnections between objects. Attendees will be exposed to a new modeling primitive (contract) that has proved to be highly effective for controlling the complexity of system design and evolution. They will learn how to use it to externalize embedded coordination directives, ending-up with systems that can evolve simply by adding, removing, or replacing interconnections without having to change the other components. Because the concept is intrinsically language-independent, and an implementation pattern is provided, attendees will be able to put it to practice immediately in their working environments. Presentation Format: 50% lecture + 50% group exercises. Attendee Background: Familiarity with object-oriented conceptual modeling José Luiz Fiadeiro is Professor of Computing Science at the University of Lisbon. His research interests include software specification formalisms and methods, especially as applied to component-based, reactive systems, and their integration in the wider area of General Systems Theory. His main contributions have been in the formalization of specification and program design techniques and of their underlying modularization principles, namely in connection to Software Architectures. These research interests have been pursued in the context of several national and international projects. He has published more than 70 papers in these areas, including the foundations of object-oriented systems. Luís Filipe Andrade is partner and Technical Vice-President of Oblog SA (www.oblog.com) in Portugal and Oblog Technology Inc. in the USA – an Information Technology Company owned by one of the most important Portuguese financial groups (“Espírito Santo”). This company has developed, under his coordination, a sophisticated object-oriented specification language (OBLOG) and its supporting tools. He is also partner and president of a software company that develops banking applications and tools based on the OBLOG language, and has extensive experience in projects implementing transactional systems to support the front-end transactions of bank branches. Previously, he had been Information Technology Manager in the biggest Portuguese financial group - CGD - and senior researcher at INESC, an institute for System and Computer Engineering where he led a research project in specification models, compilers, and code generators that later became a commercial product.

When writing applications in C++, the Standard Template Library (STL) is of great help. It provides several container types (such as list, vector, map) and algorithms to be used in combination with these containers (such as sort and find). However useful STL may be, there will be a moment that you need something you would expect to be in STL, but which is not. Then it is useful to know how you can create new containers and algorithms in the spirit of STL. In this way your own container types and algorithms will work with standard STL containers and algorithms. The STL has been set up to make these extensions possible. Though it is not difficult to extend STL, there are some guidelines to follow. After the tutorial you will know what rules to follow when creating new STL-like containers (including their iterators) and algorithms. The examples will give you enough material to base your new container types on. The objective of this tutorial is to teach the attendees how to make more use of the C++ STL by creating new container types and algorithms in the STL way. Presentation Format: This tutorial will be Presentation based. Attendee Background: Attendees are expected to know C++ and normal use of STL. Jan Christiaan van Winkel has a BS and a MS in computer science (the MS from the Vrije Universiteit Amsterdam). He works at AT Computing, a small courseware and consulting firm in Nijmegen, the Netherlands. 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 have been published as a book by the Dutch publisher AcademicService. Except for 1995, J.C. van Winkel has presented tutorials at all OOPSLA’s since 1993. He is the Dutch representative in the ISO C++ standardization committee SC22/WG21.

This tutorial focuses on how to use XML within large-scale component-based distributed system development and for e-business solutions. After placing XML in the context of component-based development and interoperability between systems and components, the tutorial discusses approaches and architectures for using XML to build large-scale systems. The tutorial addresses principles for run-time scalability and how to improve cost-effectiveness of large-scale development using XML. Topics include shortcomings of DTDs, the role of a tagged-data repository, the required switch from a strongly-typed toward a strongly-tagged mindset, the role of XML in the larger picture of enterprise-level development, a global interoperability model, and more. Attendees will come away with a real-world perspective of how XML is used for component-based development and e-business, and the kind of issues, and possible solutions, that one can expect from a strong adoption of XML for distributed system development and e-business. Presentation Format: Presentation-based. Attendee Background: Participants should have a general familiarity with distributed system development issues, and preferably with object-oriented analysis and design. Familiarity with the XML specification and related technologies is very useful but not required. The intended audience is professionals planning to use or currently using XML and charged with architecting, developing, or managing large-scale distributed systems. Peter Herzum, co-founder and Chief Technology Officer & Software Ecologist of Vayda & Herzum, is considered the guru of component-based development for the enterprise. Peter is the creator of the Business Component Approach, the first approach entirely based on components, and principal author of the groundbreaking book, “Business Component Factory: A Comprehensive Overview of Component-Based Development for the Enterprise,” which has been described by analysts as “the bible of e-business component development.” Peter has over 15 years experience in the industry, and he has led large-scale component-based product development and solution development since 1992. Peter also has extensive experience in consulting, mentoring, and training for large organizations. He is a frequent speaker at conferences across the world (including tutorials at OOPSLA‘99, OOP2000, ObjectWorld, Component Development, XML ONE, and others), and an active member of the OMG. Peter holds a Dr. Eng. degree in Computer Science from the Politecnico di Milano.

Microsoft Visual Basic 6.0 is one of the best environments for rapidly building distributed applications using Microsoft Windows Distributed interNet Applications Architecture (DNA). Windows DNA is a collection of technologies built into Windows 2000 for building and deploying Web-based applications. Using Visual Basic, effective design patterns have emerged for building flexible and well-performing distributed applications. Using COM, MTS, and SQL Server 7.0, patterns involving emissaries (using iterators and support classes) and executants (to manage transactions and invoke stored procedures) are the recommended approach for implementing business services. The speaker will present UML design patterns for modeling multi-tiered architecture applications written in Visual Basic using Windows DNA. Presentation Format: This tutorial will be presentation based. Attendee Background: Participants should have a general familiarity with visual modeling and the UML. Chris Armstrong is President of Armstrong Consulting and has been teaching, mentoring, and consulting in software development processes, Requirements Management with Use Cases, and Object-Oriented Analysis and Design for many years. Chris has presented at the Rational Users Conference in 1998 and 1999 and is scheduled to present at the 2000 RUC. In addition, Chris will be presenting at UML World 2000 and the 2000 PERL developers conference. Chris has also published articles in Enterprise Development and Rose Architect magazines.

Object databases are a mature technology, although their successful usage and adoption have generally been confined to a number of vertical markets, such as financial trading systems or telecommunications network management. In part, the limited use of this technology has been due to a lack of knowledge or understanding of its full potential. Through examples, the goal of this tutorial is to educate and inform participants about the capabilities of this technology, applications for which it is well-suited, how this technology can successfully co-exist with existing database systems, and how it can be used to enhance the capabilities of existing database systems in multi-tier architectures. After attending this tutorial, participants will possess a good understanding of the major issues described above and will be able to apply a decision framework that will assist them in determining if object databases are appropriate for their projects. Presentation Format: The tutorial will be presentation based with attendee participation encouraged where they have useful experiences to contribute. Attendee Background: Attendees should have a working knowledge of Database Management Systems, object-oriented programming languages, multi-tier architectures, and software development techniques. Akmal B. Chaudhri has been working with object databases in both academia and industry for nearly 10 years. He has been a regular tutorial presenter and co-presenter on object databases at a number of international conferences. He has contributed papers on object databases to a number of journals, seminars and conferences and has co-edited the book “Object Databases in Practice” with Dr. Mary Loomis. He has also co-organized the very successful workshops on “Object Database Behavior, Benchmarks and Performance” at OOPSLA‘95, “Experiences Using Object Data Management in the Real-World” at OOPSLA‘97 and “Java™ and Databases: Persistence Options” at OOPSLA‘99. He is currently working on the book “Succeeding with Object Databases” with Professor Roberto Zicari. He holds a B.Sc. in Computing & Information Systems, an M.Sc. in Business Systems Analysis & Design and a Ph.D. in Computer Science. He is a member of the British Computer Society Data Management Specialist Interest Group. Bill Cole has twenty years of commercial information and engineering systems experience, the last ten years concentrated solely in object-oriented technology, utilizing Smalltalk and a variety of database technologies to implement distributed applications. He has strategically consulted with over twenty Fortune-500 firms in the area of transitioning to object-oriented technology, including OO project management, OO analysis and design, and OO software quality assurance. He is President/CEO of JumpStart Systems, Inc., and is still an active member of JumpStart’s consulting unit. He has written numerous articles on OO transition and development and has spoken at numerous industry conventions, including previous OOPSLAs.

Responsibility-driven design is a method for describing objects in terms of roles, responsibilities, and their collaborative behavior. This tutorial briefly introduces you to responsibilities and the responsibility-driven design process, then spends most of the time presenting practical techniques for improving, understanding, and expressing models and thinking about design. These techniques include CRC cards, object role stereotypes, control style analysis, behavior refactoring worksheets, and hot spot cards for identifying and planning design variations. These techniques can be successfully added to your current design toolkit and complement UML design models. Attendees will have an opportunity to briefly practice several of these design techniques. Student notes consist of a case study illustrating techniques and results. Participants will learn a number of informal design modeling techniques that can be used to reason about their objects, their patterns of collaboration, and choices for using inheritance and composition. Students will learn how behavioral techniques and thinking in terms of responsibilities can complement and enhance more formal design models. Presentation Format: Slides, lecture, and at least two short exercises followed by clinic/review sessions. Attendee Background: Students should be familiar with object concepts and have had some exposure to object design. Students should be interested in learning several informal modeling techniques. Rebecca Wirfs-Brock is president of Wirfs-Brock Associates, a firm specializing in transferring object analysis and design expertise to organizations and individuals through training, mentoring, and consulting. She spent 17 years as a Software Engineer at Tektronix, and led Tektronix’ development of Color Smalltalk. She has written articles, lectured and presented tutorials on object analysis, design and management topics, and has been an innovator in object technology since 1984. Rebecca is co-inventor of the Responsibility-Driven Design method, co-author of the classic, “Designing Object-Oriented Software,” and author of a new book on object design (to be published by Addison-Wesley when it is finished!) Alan McKean, Vice President of Training at Wirfs-Brock Associates, and co-author of a new design book with Rebecca, has devoted his career applying principles of design and adult learning to find better ways to communicate technical information. A student of Buckminster Fuller’s and an MSCS graduate of the University of Oregon, he specializes in system architecture and design. An experienced speaker and software developer, he has developed core curricula in object-oriented development and distributed object systems.

Java has always promised the ability to run on any size platform, from mainframes to wristwatches. Now the promise of supporting “small” platforms is truly here. This tutorial will teach the current state of the art with respect to developing Java applications for the Sun J2ME and IBM VAME application environments (JAE’s). Developers will receive instruction on how to approach developing their own small-environment Java applications from pioneers who have built such applications using the different environments. The differences between Sun’s and IBM’s approach to putting Java in small spaces along with benefits and limitations of each will be discussed. The tutorial will also discuss integrating Java enabled devices into the much-ballyhooed Jini environment. After this tutorial, Java developers and technical leaders will have a clear understanding of the advantages, risks, challenges, and approaches of developing J2ME and VAME Java applications. Presentation Format: Presentation and demonstrations. Attendee Background: Participants should be Java developers or technical leaders of Java projects. Chris Carpenter is an employee of RoleModel Software, Inc. Mr. Carpenter architected and led development of the ABB Energy Axis Automated Meter Reading System. This is a suite of distributed software subsystems and applications that interoperate to provide a application for reading millions of electrical meters for electric utilities and other deregulated entities. The system allows near real-time collection of meter telemetry allowing far greater flexibility to the energy service provider in applying new rates and responding to a rapidly changing deregulated marketplace. The AMR is designed around the metaphor of a Centralized Distribution Warehouse. The system is designed and built to accommodate over a terabyte of meter data collected from meter devices connected via telephone, radio and satellite communications. The system is highly distributed and dynamically driven by external business logic. The system was written in C++, Perl and Java and uses DCE, RQS, Persistence and Encina middlewares. He has been awarded a patent on the AMR system. Additional patents on individually unique aspects of the system are pending. Ken Auer founded RoleModel Software, Inc. in early 1997 with a mission to provide leadership in the development of robust, flexible software assets that help meet its customers’ business needs as they continue to evolve. Mr. Auer has an excellent track record of results in a variety of business and technical roles. His experience as a developer, instructor, technical leader, project manager, and director increases his effectiveness in getting desired results by being able to see projects from a variety of angles. He skillfully balances the business and people sides of software with the technical side to maximize “real progress” toward his clients’ goals through a variety of services. Although he plays many roles well, Mr. Auer’s most natural role is Chief Architect/Technical Leader in which he develops software, software development teams, and software developers. His goal is to reproduce leadership skills in RoleModel Software’s employees while encouraging them to make the most of their unique God-given talents in the software field.

While Software Patterns are undeniably powerful design aids, many programmers tend to overuse them, prematurely introduce them, or implement them in unnecessarily heavyweight ways. Refactoring to Patterns encourages a simpler, more disciplined approach to using Patterns, based on the philosophy of eXtreme Programming. Using this approach, programmers wait for the right time to refactor a Pattern into a system and do so using the simplest possible Pattern implementations. In this tutorial, we will examine 5 Design Patterns and 5 cases where we might refactor these Patterns into Java code. During the process, we will investigate when it makes sense to refactor to a Pattern, and what are simple implementations of each Pattern we add. Presentation Format: Lecture and group participation. Attendee Background: This is an intermediate-level tutorial. Attendees will be expected to understand Java and have basic exposure to Design Patterns. Joshua Kerievsky is founder of and principle consultant for Industrial Logic, Inc. (http://industriallogic.com). He founded the first public patterns study group in 1995, was conference chair of Using Pattern ‘97, designed and actively teaches the Design Patterns Workshop (http://industriallogic.com/training/ili_dpclass.html) and the online Programming with Patterns workshops (http://industriallogic.com/training/pwp.html). He contributed a Refactoring to Martin Fowler’s book on the subject, and has been active in the eXtreme Programming community since its inception.

Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Software engineers are now confronted with millions of lines of industrial source code, developed using object-oriented design methods and languages of the late ‘80s. These systems exhibit a range of problems, effectively preventing them from satisfying the evolving requirements imposed by their customers. This tutorial will share our knowledge concerning the reengineering of object-oriented legacy systems. We will draw upon our experiences with the FAMOOS project to show you techniques and tools we have applied on real industrial OO systems to detect and repair problems. In particular, we will discuss issues like tool integration, design extraction, metrics, refactoring, and program visualization. Additional information concerning this tutorial can be obtained at http://www.iam.unibe.ch/~scg/Teaching/Tutorials/OOPSLA00_OOReeng/. Presentation Format: This tutorial will be presentation based. Attendee Background: Participants should have practical programming experience in at least one OO language (Smalltalk, C++, Java, Eiffel, etc.). Familiarity with UML is useful, though not required. Serge Demeyer is a professor at the University of Antwerp (Belgium), while Stéphane Ducasse is a post doctoral researcher at the Software Composition Group in Berne (Switzerland). Both of them served as technical leaders for the FAMOOS project and as such have been involved in the organization of several workshops (at ECOOP and ESEC) concerning object-oriented reengineering. They have given tutorials on Object-Oriented Reengineering at both OOPSLA and ECOOP and are currently writing a book reporting on their experience.

Tutorials at a Glance

Tutorials by Track

Full Description of all Tutorials

Final Program