 |
|
Monday Full Day
| 2 | Aspect-Oriented Programming with AspectJ Gregor Kiczales, Xerox Palo Alto Research Center Cristina Lopes, Xerox Palo Alto Research Center |
Colorado Convention Center - A102  |
| Objects have been a great success. Object-oriented programs have a natural modularity that makes them easier to develop and maintain than purely procedural programs.
But object-orientation doesn't solve all modularity problems. Many common design concerns are difficult to localize in an object-oriented program. Instead, their nature makes them cross-cut the system's class structure. These cross-cutting concerns include things like multi-object interaction protocols, object roles, certain design patterns, performance optimizations, synchronization constraints, distribution issues and many others. Aspect-oriented programming is a new technique proposed to address the problem of cross-cutting concerns. Aspects are program constructs that make it possible to capture cross-cutting concerns in a clear and modular way - aspects are intended to modularize cross-cutting concerns in the same way that objects modularize units of functionality and state. This tutorial shows how to design and program with the AspectJ extension to Java. Particular attention will be given to how AspectJ can support the implementation of common design patterns and Java programming idioms. Attendee Background: Attendees should be able to read and understand Java code. Gregor Kiczales is a principal scientist at the Xerox Palo Alto Research Center. His research is focused on a range of topics in software design, including object-oriented programming, metaobject protocols, open implementation and aspect-oriented programming. He is a co-author of "The Art of the Metaobject Protocol". He is a member of the AspectJ design team. Cristina Videira Lopes is a research scientist at the Xerox Palo Alto Research Center. Her research interests are in software engineering and programming languages, with a focus on aspect-oriented programming support for distributed systems. She is a member of the ApsectJ design team. |
| 3 | Software Architecture: It's What's Missing From OO Methodologies Norm Kerth, Elite Systems Gerard Meszaros, Clearstream Consulting |
Colorado Convention Center - A201 |
| 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 never the less 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.
The teaching style is case base driven, and hands-on in nature, with lecture intermixed to extend a participatory learning experience. Attendee Background: The attendee is assumed to have experience building at least one real-life software system of substantial size. Norm Kerth is a consultant working with mastering object-oriented technologies. He includes the wider issues of specification and design activities, quality assurance, continuous process improvement, project management and building effective teams. Prior to starting his company, Elite Systems, he was a professor 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. Prior to becoming a consultant, he was a software architect and project manager overseeing the development of software for switching telephone calls. |
| 4 | Object-Oriented Reengineering Serge Demeyer, Stephane Ducassse Oscar Nierstrasz, University of Berne - Software Composition Group |
Colorado Convention Center - A108 |
| 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 demonstrate techniques and tools we have applied on real industrial OO systems to detect and repair problems. In particular, we will discuss issues like metrics, design recovery, refactoring, tool integration.
The tutorial is targeted at programmers involved in maintenance and reengineering of large OO systems. Researchers interested in topics like metrics, design recovery, refactoring are welcome as well. Participants will learn how metrics, UML, and refactoring can help in reengineering OO systems and see tools that may support them in this task. 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 and Stephane Ducasse are post doctoral researchers in the Software Composition Group in Berne, serving as technical leaders of the FAMOOS esprit project; a project whose goal it is to come up with a set of reengineering techniques and tools to support the development of object-oriented frameworks. Oscar Nierstrasz is a Professor of Computer Science at the University of Berne, where he leads the Software Composition Group. He has been active in the object-oriented research community for many years, serving on program committees of among others, ECOOP, OOPSLA and ESEC. He has given several tutorials and invited talks on object-oriented technology at various international conferences and workshops. |
| 5 | Writing Effective Use Cases Bruce Anderson, IBM Object Technology Practice Alistair Cockburn, Humans and Technology |
Colorado Convention Center - A205 |
| The tutorial aims to get you clear on the role of use cases in the project and requirements process, to know where they fit, how they look, how they don't look, how UML and various tools affect them, and how to adjust your writing style to get them to communicate effectively. In this full-day tutorial, we shall outline and then write a few use cases, correct some (genuine!) badly written use cases, and trade experiences on the subject. We will also see what not to put in use cases. The speakers will give both theory and practicum, for example answering the questions asked at OOPSLA 1998's panel session on use cases. Experienced use case writers will benefit from the exchanges with other experienced writers. Newcomers to use cases will benefit from the exchanges between experienced writers. Everyone should benefit from the peer discussion of the writing assignments and the combined experience of the presenters. This will be a highly interactive session.
Attendee Background: This tutorial is for the person faced with writing or editing a requirements document. No object-oriented knowledge is needed. Bruce Anderson, Senior Consultant in the IBM Object Technology Practice, has been using use cases in his consulting work for several years. He has helped clients with requirements and modeling in the banking, insurance, petroleum and telecom industries. Bruce and Alistair both served on the OOPSLA '98 use case panel. Alistair Cockburn founded Humans and Technology, designed the OO methodology for the IBM Consulting Group in 1992, and was special advisor to the Central Bank of Norway. He is preparing the book "Writing Effective Use Cases", and published the book "Surviving OO Projects". Use cases and other materials that support Alistair's workshops can be found at http://members.aol.com/acockburn . |
| 6 | Concepts of Object-Oriented Programming Raimund K. Ege, Florida International University |
Colorado Convention Center - A106 |
| 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:
A small case study will be used to illustrate the solution in each language. Attendee Background: Attendees are software professionals who are interested in learning the fundamental concepts and advantages of object-oriented programming and how to apply them in a modern software development environment. No previous knowledge of object-oriented concepts is assumed. The attendees should have a fundamental background in computer science and/or computer programming. Raimund K. Ege is a consultant and lecturer, and a computer science professor at FIU in Miami, FL. 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. |
| 7 | Software Architecture and the UML Dr. Wojtek Kozaczynski, Rational Software Dr. Philippe Kruchten, Rational Software |
Colorado Convention Center - A104 |
| 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 major architecture views and models and their representation using the UML. It also provides an overview of some of the software architectural styles and includes a discussion on how architectures drive the development process. The tutorial concludes with a presentation of examples of architectural patterns using the UML.
The objective of this tutorial is to give the attendees the guidelines on how to use the UML to represent the architecture of a software-intensive system and how to express some architectural patterns in UML. Attendee Background: There are no specific perquisites for this tutorial. Dr. Wojtek Kozaczynski is the Director of Architecture Practice at Rational Software. Dr. Kozaczynski has some 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. Dr. Philippe Kruchten is the Director of Process Development at Rational Software Corp. He has some 25 years of experience in development of large-scale software-intensive systems in the areas of telecommunication, defense, aerospace, transportation, and software development tools. Dr. Kruchten 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 telecommunication manufacturer Alcatel. |
| 9 | Condensed Java: A 1-Day Tour Carol J. Meier, .profile Consulting Inc. George Watson, Epilog Corp. |
Colorado Convention Center - A207 |
| This course will cut through the hype surrounding Java to answer your questions about Java and its popularity, uses, history, features, portability, shortcomings, performance, security, standardization, licensing, and anything else you want to know about how it fits into the computing world. We'll take you on a technical tour of Java's language features and libraries. We'll explain, with program examples, the language basics, O-O support, packages, interfaces, exceptions, dynamic class loading, threads and synchronization, reflection, garbage collection, and native methods. Next, we'll tour the rich set of libraries supporting I/O, data structures, networking, GUIs, applets, database connectivity, remote method invocation, internationalization, media and more. As time permits we'll address security, implementation technologies, Java Beans, Media APIs, JINI, JavaOS, JavaMail, JMAPI, JNDI, JMS, JFC, and more. Our goal is to give you all the information you need to evaluate Java's suitability for your projects.
Attendee Background: Intermediate level experience with any common programming language. You don't need to be an object-oriented programmer, but the more technical your background, the more you will get from the course. Language features will be presented at several levels, to accommodate a diverse audience. Seat belts recommended. Carol Meier, currently owns, operates, develops courseware, teaches and consults for .profile Consulting Inc. She has been developing software for almost 20 years, first at Bell Labs, than as an independent consultant, and for seven years as co-founder of XVT Software Inc. Since 1984 Carol has been teaching C, C++, UNIX and more recently Java for the University of Colorado. George Watson is currently developing embedded systems and device drivers for Epilog Corporation. He has been developing software for 20 years, working with object technologies for the past 10 years, and using Java since 1995. George has extensive experience in OOA&D, molecular modeling, computer-aided dispatch, health care and other areas. As an instructor, George has taught algorithms and operating systems theory, and has been teaching Java for 3 years. |
| Software patterns are a literary form, designed to communicate expert knowledge about system construction. This course teaches pattern-writing skills in the context of the broader goals and values of the pattern community. The course mixes lecture with exercises and small workshops. Each participant will write a pattern and participate as an author in a writer's workshop. This innovative tutorial is held over two days so that participants are immersed in the activity and culture of pattern writing.
Attendee Background: A basic software design background is helpful, but not necessary, to fully benefit from the workshop. We encourage attendance by individuals with diverse backgrounds, including (especially!) areas outside computer science. Jim Coplien is a Distinguished Member of Technical Staff at Bell Laboratories in Naperville, Illinois. He is the author of the "Software Patterns" management briefing and co-editor of several pattern books. Richard Gabriel is author of "Patterns of Software," and holds an MFA in Poetry from Warren Wilson College. He is well-known in the pattern community for introducing the writers' workshop format for pattern review. Christa Schwanninger is a software engineer at Siemens Corporate Technology in Munich where she works on distributed applications. She has done pioneering work in patterns for compiler construction and language design. Honna Segel works for Nortel Networks in the development of advanced services. She has both used and developed various apsects of object-oriented technology and has led workshops at OOPSLA in domain analysis and framework development. |
Monday Morning/Half Day
| 11 | Responsibility-Driven Design: Practical Techniques for Modeling Object Behavior Rebecca Wirfs-Brock and Alan McKean, Wirfs-Brock Associates |
Colorado Convention Center - A209 |
| Responsibility-driven design is distinguished from other methods is its emphasis on describing objects and their collaborative behavior, and its use of informal tools that aid in thinking about design. This tutorial presents an overview of the responsibility-driven design process and shows several techniques for improving, understanding, and expressing object design models. Student notes consist of an extensive case study illustrating techniques and results. 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 applied to augment your current design toolkit and complement UML design models. This tutorial gives attendees an opportunity to briefly practice these design techniques.
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 models can complement and enhance more formal design models. Attendee Background: Students should be familiar with object concepts and have some exposure to object design modeling. Students should be interested in learning how informal modeling techniques can fit into an object design process. 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 Tek's development of Color Smalltalk. She has 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 and co-author of the classic, "Designing Object-Oriented Software." Alan McKean, Vice President of Training at Wirfs-Brock Associates, 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. |
| 12 | Efficient Implementation of Object-Oriented Programming Languages Craig Chambers, University of Washington |
Colorado Convention Center - A202 |
| 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 interprocedural 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.
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. |
| 14 | Developing Java Applications for Small Spaces Ken Auer, RoleModel Software, Inc. |
Colorado Convention Center - A111 |
| Java has always promised the ability to run on any size platform, from mainframes to wristwatches. Now the promise of supporting "small" platforms may finally be imminent. This tutorial will teach the current state of the art with respect to developing Java applications for the PersonalJava and EmbeddedJava application environments (JAE's). Developers accustomed to creating applications for the web, desktop, or workstation environments will receive instruction on how to approach developing their own small-environment Java applications from pioneers who have actually attempted (successfully and unsuccessfully) to build such applications. Although many developers are familiar with various versions of the JDK, significantly fewer have really looked at PersonalJava and EmbeddedJava in any depth. These developers would typically spend valuable time researching the technologies and heading down fruitless paths. However, attendees of this tutorial will be prepared to successfully develop for these environments.
Attendee Background: Participants should be Java developers or technical leaders of Java projects. Ken Auer is the founder of RoleModel Software, Inc., the company that transforms innovative ideas into world-class products and potent software development capabilities. In the summer of 1997, his company began the first in a series of projects putting object-oriented technology on handheld and other embedded platforms. He is the co-author of the forthcoming book "Extreme Programming Applied: Playing to Win". Prior to founding RoleModel Software, Mr. Auer served as Director of Applied Technology at Knowledge Systems Corporation. |
| 15 | Introduction to Distributed Computing using Objects Eric Jul, University of Copenhagen |
Colorado Convention Center - C201 |
| As computer networks become faster and cheaper, it becomes more and more desirable to use distributed computing. Object-oriented programming seems to mesh exceptionally well with the paradigms of distributed programming because of object encapsulation and the clean interface presented by an object.
The aim of this tutorial is to teach the basic ideas and paradigms of distributed object computing rather than a specific technology. Issues covered include:
This tutorial is for object technology users that would like to obtain a basis understanding of the concepts behind distributed object, and professionals that are about to embark on using distributed objects, e.g. JAVA, CORBA, or WWW. Attendee Background: The tutorial assumes basic knowledge of object-oriented concepts. No previous knowledge of distributed computing is required, however, experience with one or more OO programming languages would be helpful. Eric Jul is an Associate Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he heads the DistLab group which is doing research in distributed, heterogeneous computing. He is a co-designer and principal implementor of the Emerald distributed object-oriented programming language developed at the University of Washington. Dr. Jul was Program Chair for ECOOP`98. |
| 16 | Introduction to the OPEN method with UML B. Henderson-Sellers, University of Technology, Sydney B. Unhelkar, CASE digital |
Colorado Convention Center - C103 |
|
OPEN is the premier third-generation, process-focussed, public domain OO methodology. It is documented in a number of professional-level texts. In this tutorial, OPEN is introduced through a number of case studies using UML Version 1.3 as the notation, which will itself be explained in the tutorial without assuming previous experience in UML.
The overall aims of the tutorial are to describe the third generation OPEN methodology at an introductory level by means of case studies which illustrate the tailorable flexibility of the OPEN process. Attendees will also gain hands-on experience in methodology tailoring and UML modeling in a small case study. Attendee Background: Knowledge of OO concepts will be beneficial; no knowledge of methodologies or modeling is required. This is an intermediate level tutorial which will be of most benefit to systems developers, analysts, designers, students and faculty with basic knowledge of OO concepts who require an easy introduction to modern OOAD methodological thinking. Brain 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 meta-modeling (MOSES, COMMA and OPEN) and in OO metrics. Bhuvan Unhelkar is Chief Operating Officer with CASE digital and has over 16 years of professional IS experience. He holds a Doctorate in the area of OO design and is winner of the Computerworld Object Developers Awards for "Best use of an object-oriented approach across the organization". |
| 17 | Advanced ENVY System Programming Alan Knight, The Object People Joseph Pelrine, Daedalos Consulting |
Colorado Convention Center - A113 |
| One of the strong points of a Smalltalk environment is the extensibility of the IDE. ENVY is the premier version control and configuration management tool for Smalltalk, and while its tool set is extensive, many useful extensions are possible. This code-intense course provides an in-depth look at the ENVY system API and internals, and provides numerous examples of tools and scripts which can immediately be used to increase the productivity of an ENVY site. Students will gain an understanding of ENVY mechanisms and API, useful in day-to-day use, but primarily focused on tool-building. Topics covered include an overview of the ENVY API, a packaging assistant which can intercept and interpret packaging-related errors, creating "library specifications" to manipulate software components, scripting facilities, integrating refactoring facilities into ENVY, and a standard mechanism for third-party applications to extend the system menus. This tutorial covers both VisualAge and VisualWorks.
Attendee Background: Attendees should have a good understanding of Smalltalk, and be familiar with ENVY. Alan Knight has been involved with objects and Smalltalk for over a decade. He has been a regular columnist for The Smalltalk Report, and has spoken extensively on Smalltalk and ENVY. He currently works at The Object People as architect for the TOPLink family of persistence products., and is co-author, together with Joseph Pelrine and Jan Steinman of the forthcoming book "Mastering ENVY/Developer" from SIGS Books/Cambridge University Press. Joseph Pelrine is an expert Smalltalk programmer with over ten years extensive OT experience. A former columnist for The Smalltalk Report, and noted international speaker, he is currently a senior consultant with Daedalos Consulting in Switzerland. He is the author of various ENVY-related tools, including a Refactoring Browser integration. |
| 19 | Testing Object-Oriented Software Systems John D. McGregor, Software Architects & Clemson University Melissa L. Major, Software Architects |
Colorado Convention Center - C105 |
The focus of this tutorial is a set of techniques and a process for testing a complete software application built as part of a project that uses object-oriented software development techniques. The tutorial is divided into three parts:
The techniques presented in the tutorial are intended to provide a scalable process that can be tailored to the size of a project and the degree of coverage required by the type of application. The three major benefits from this tutorial include specific testing techniques, a comprehensive testing strategy that is integrated into the development process, and a specific infrastructure for building a reusable testing environment. Attendee Background: Participants should have participated in the specification and testing of complete applications that were constructed using object-oriented development techniques. System testers and software developers interested in the complete product realization process will benefit from this tutorial. Test managers and quality control personnel who are technically oriented will also benefit. 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 co-author of "Object-oriented Software Development: Engineering Software for Reuse". 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. Ms. Melissa L. Major is a Consultant and Site Manager for Software Architects. She has worked for Computer Aid, Broadway & Seymour, BNR/NORTEL, and as a contractor within Microsoft. She has a masters in Computer Science and has been a Ph.D. student at Clemson University. Ms. Major has taught computer science courses for Clemson University and Limestone College. She has managed testing efforts and constructed software development processes including testing processes for companies such as Lucent Technologies. |
| 20 | Producing Usable GUIs with the Java Foundation Classes (JFC) Fintan Culwin, South Bank University |
Colorado Convention Center - C107 |
| The JFC supplies a number of different user interface components. This tutorial attempts to introduce a representative selection of the most common and useful of them, showing how they can be combined to produce effective user interfaces. To accomplish this efficiently it is necessary to start with a representation of the required behavior of the interface and derive the detailed design from it.
The objectives of this tutorial are:
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. Fintan Culwin is a Reader in Software Engineering Education at South Bank University, London; specializing in Software Engineering and HCI, 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. |
| 21 | Putting Metaclasses to Work Ira R. Forman, IBM |
Colorado Convention Center - C109 |
| The purpose of this tutorial 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 metaclass that do compose with each other. The attendee will attain an understanding of why metaclasses are 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. 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. 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." |
| 22 | Multiparadigm Design & Efficiency in C++ Stanley Lippman, Objectwrite, Inc. |
Colorado Convention Center - C112 |
| In this talk, we present a series of C++ programming design idioms for writing efficient C++ programs, briefly review the underlying C++ object model, and turn to design alternatives when the idioms themselves become overwhelmed with, say, large-scale object creation and copy. We look at object-based and object-oriented design, use of the STL container classes and generic algorithms, and the design alternatives of inheritance versus parameterization through use of the C++ template facility. This is a particularly effective area of program efficiency because (a) the idioms generally make for more readable programs, and (b) once the idioms and implementation (or object) model is internalized, these gains in efficiency come mostly for free.
Attendee Background: Programmers either using or about to use C++ for the delivery of production code in which efficiency is a concern. Stanley Lippman is a consultant in both the entertainment and aerospace industries in the efficient use of C++ for large-scale software systems. Prior to this, he was principal software engineer at Walt Disney Feature Animation, then software technical director for a segment of Fantasia 2000. While at AT&T Bell Laboratories, he led the cfront Release 3.0 and Release 2.1 compiler development team. Following that, Stan was a member of the Bell Laboratories Foundation Project, responsible for the object model component of a research C++ programming environment. |
| 23 | UML Distilled: Techniques for Object-Oriented Analysis and Design Martin Fowler, Independent Consultant |
Colorado Convention Center - C104 |
| 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 is a grand tour of the UML: giving 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.
Objectives: 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. We'll also look at important non-UML techniques that should be used in conjunction with the UML. Attendee Background: Attendees should understand basic OO concepts. Martin Fowler has spent over a decade to applying object technology to business information systems. He is an independent consultant who trains and mentors his clients in OO analysis, design and programming, patterns, and refactoring. He has used more analysis and design notations than he can remember, and is glad the UML cuts down on that. His recent clients have included: Chrysler, IBM, Sterling Software, and Andersen Consulting. He is a popular speaker on the conference circuit and the author of the Addison-Wesley books "Analysis Patterns" and "UML Distilled", which he likes to think is the worlds smallest methodology book. |
Monday Afternoon/Half Day
| 24 | Patterns for Distributed and Agent-based Object Systems Craig Larman, ObjectSpace |
Colorado Convention Center - C201 |
This tutorial presents a collection of practical patterns to develop distributed software architectures; these patterns range from the mundane to the sublime. However, they are unified by one common theme: it is not the functional requirements of the system that dominate distributed software design; it is instead the modal requirements, e.g., performance, reliability, scalability, security and cost-effectiveness. In addition, some emerging patterns to improve configuration, extensibility, and reliability by using mobile agents are explored. On this tour, we introduce:
The tutorial provides an information-rich and panoramic glimpse inside the (slightly paranoid) world of distributed application design. The principal objective of this tutorial is to provide the participants with a set of practical patterns that can be frequently applied in distributed software design. Attendee Background: Participants should be at least cursorily familiar with distributed computing and have an interest in exploring the design issues and techniques of building industrial-strength clients and servers. Craig Larman is the author of "Applying UML and Patterns--An Introduction to OOA&D" and "The Java 2 Performance and Idiom Guide", and is Principal Instructor at ObjectSpace. He also writes the "Modeling and Java" column in Java Report. He has been using object technologies since 1984 when he started developing knowledge systems on LISP machines. For over a decade he has assisted others in developing object systems, in applying object-oriented analysis and design, and in technologies such C++, Java, and Smalltalk. His current focus is the design of distributed systems with EJB. Craig holds a B.Sc. and M.Sc. in computer science, with research emphasis on object-oriented knowledge representation and case-based reasoning. |
| 25 | Catalysis - Systematic Components and Framework with UML Desmond D'Souza, Platinum Technology |
Colorado Convention Center - A111 |
We describe a simple, consistent use of UML to:
More details are at http://www.catalysis.org . Participants will learn how to (a) simplify their usage of UML, (b) distinguish components from objects, (c) separate component specifications from designs, (d) apply re-use from requirements through architecture to code using model frameworks, (e) keep models and designs separable, maintainable, and traceable. Attendee Background: Attendees should be familiar with object modeling and programming, design patterns as defined by Gamma et al, and use-cases. Those wanting to use patterns with UML, a consistent component-based approach, clear ways to compose and refine models, and design methods suited for languages like Java, will benefit. Desmond D'Souza is VP of component-based development at Platinum Technology, co-author and developer of the Catalysis method for systematic development of business-driven component systems, published by Addison Wesley. A frequently invited speaker to companies and conferences, and writes the Modeling for Java column in the Journal of Object-Oriented Programming. |
| 26 | Analysis and Redesign of Object-Oriented Software Architectures Wolfgang Pree, Univ. of Constance Rick Kazman, Software Engineering Institute / CMU |
Colorado Convention Center - C103 |
| Development teams often don't pay enough attention to the explicit design of the coarse-grained modularization of software systems. This leads to quality deficiencies affecting, for example, the performance, extensibility and maintainability of the systems at hand. Our tutorial presents a well-chosen set of concepts and tools that support software design at the architecture level of abstraction.
The tutorial starts with the definition of relevant terms. It goes on to present the basic concepts required for architecture analysis and (re)design. Among these are known heuristics of how to modularize software systems and how to describe architectures, architectural patterns, and hot spot analysis. The analysis activity is crucial in ensuring that a large and costly development project meets its quality goals. Such an analysis can be used for acquisition, for new projects, or for planned maintenance and reengineering activities. The tutorial introduces two methods for architecture analysis. Case studies exemplify the application of these methods. A thorough analysis also forms the precondition of an architecture evolution of legacy systems. A case study illustrates how small object-oriented frameworks, called framelets, help in the process of refactoring replicated code fragments. An experience report on the benefits and costs of applying the presented aspects of architecture-centered design in various projects concludes the presentation. Wolfgang Pree is a professor of computer science at the University of Constance, Germany, and head of the Software & Web Engineering group. His research covers various areas of software engineering, in particular object and component technology, software architectures, and human-computer interaction. Wolfgang is the author of Design Patterns for Object-Oriented Software Development (Addison-Wesley, 1995). Rick Kazman is a Senior Research Scientist at the Software Engineering Institute of Carnegie Mellon University and Adjunct Professor at the Universities of Waterloo and Toronto. He is the co-author of over 50 papers and several books including Software Architecture in Practice (Addison-Wesley, 1998). |
| 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. Such models guide user interface design more effectively toward ease and efficiency of use. Through discussion, illustrative examples, and hands-on application, this tutorial will introduce techniques for constructing and elaborating User Role Models, deriving compact Use Case Models in essential form, and applying these models to realistic problems in user interface design.
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. 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 is a Research Fellow in Object-Oriented Design at the Microsoft Research Institute at Macquarie University, Sydney. James has ten years experience working and researching with object-oriented systems, and has presented papers and tutorials on object-orientation and usage-centered design on three continents. 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). |
| 28 | Garbage Collection Richard Jones, University of Kent Eric Jul, University of Copenhagen |
Colorado Convention Center - A202 |
| This tutorial presents the issues facing modern high performance garbage collection and examines the approaches taken by state of the art garbage collectors. Participants will gain a deeper insight into the operation of these high performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors.
Attendee background: Participants will be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential. 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. He is a member of the Steering Committee of the International Symposium on Memory Management and was Program 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. He was Program Chair for ECOOP`98. |
| 29 | Virtual Classes in the BETA Language Ole Lehrmann Madsen, Aarhus University |
Colorado Convention Center - C102 |
| Generic classes or types are most often supported by parameterized classes based on various forms of parametric polymorphism. In OO languages virtual classes present an alternative where new classes are derived from generic ones using inheritance rather than function application. Both mechanisms provide the same basic form of genericity but differ in interesting ways. Virtual classes first appeared in BETA, and have successfully been used for more than 15 years. The tutorial will present basic elements of BETA with main emphasis on virtual classes and will discuss typing issues such as substitutability, co- and contravariance, static typing, etc. The participants will get a detailed introduction to basic elements of BETA, in particular virtual classes. The participants will learn about the pros and cons of virtual classes compared to other proposals for type parameterization.
The participants will be able to evaluate the many proposals in the literature for generic types based on virtual classes and parameterized classes. Finally the participants will become familiar with the implementation of virtual classes. Attendee Background: Participants should be experienced with object-oriented programming and be familiar with issues regarding parameterized classes including static typing, substitutability, co-/contravariance, etc. The speaker has been working with OO since the early seventies, starting with Simula. He is one of the designers of BETA and he was the main designer and implementer of the Mjolner BETA compiler. He has participated in many projects on OO in research as well as industry. He is currently a professor in Computer Science at Aarhus University and research director of the Danish National Centre for IT Research. He is co-founder and president of the board for Mjolner Informatics, which develops and markets the Mjolner System. |
| 30 | Roll Your Own Language in Java Steve Metsker, Capital One |
Colorado Convention Center - C108 |
| Application developers have lots of chances to use little languages, but you have to know how to see and seize the opportunity. When text appears in patterns, as it does in markup languages, user edits and in most web sites, there is usually a chance to put a new little language to use. The Interpreter pattern in "Design Patterns" shows how to create new languages, but this is a difficult pattern to master without a tutorial. By attending this tutorial, you will gain the tools to start seeing and seizing opportunities for creating new little languages.
Attendee Background: Attendees should understand the object-oriented principles of inheritance and polymorphism. The examples are all given in Java, so attendees should recognize basic Java syntax. Steve has worked with Basic, Fortran, PL/I, C, Smalltalk, and Java, in Fort Collins, South Portland, Austin, Zug, Lexington and Richmond, pretty much in that order. He wrote, "Java Rules", an article about applying the Interpreter pattern, in February, 1998, for Java Report. Feedback from that article convinced Steve that a lot of people would be interested in a tutorial on how to roll their own new little languages. |
| 31 | Testing Distributed Object Systems John D. McGregor, Software Architects & Clemson University |
Colorado Convention Center - C112 |
The focus of this tutorial is on techniques and a process for testing components built to be distributed across multiple processes. The tutorial will address techniques that are common to all architectures as well as those limited to a specific distribution architecture such as CORBA. The tutorial will provide examples that use specific architectures. The tutorial is divided into three parts:
The techniques presented in the tutorial are intended to provide variable levels of coverage and to allow the developer to focus on specific types of faults. The major benefits from this tutorial include specific testing techniques, and a specific infrastructure for building a reusable testing environment. Attendee Background: Participants should have participated in the construction of distributed object-oriented programs and performed some level of testing on the program. Component developers and technically-oriented system testers will benefit from this tutorial. Test managers and quality control personnel who are technically oriented will also benefit. Dr. John D. McGregor is an associate professor of computer science at Clemson University and a senior partner in Software Architects, a software design consulting firm, specializing in object-oriented design techniques. Dr. McGregor has developed testing techniques for object-oriented software and developed custom testing processes for a variety of companies. Dr. McGregor is co-author of "Object-oriented Software Development: Engineering Software for Reuse". 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. |
| 32 | Beyond UML: A Unified Model of Component Concepts John Daniels, Sterling Software John Cheesman, Sterling Software |
Colorado Convention Center - C109 |
| There is considerable confusion over the meanings of object and component, and over the relationship between these concepts. This tutorial aims to provide attendees with a precise but technology-neutral definition of software component, and will show how such a definition facilitates technology-independent component modeling and specification. It will also explain how this definition relates to that in the UML and show how UML notations can be best used to represent components.
The tutorial will present a conceptual model for components, expressed using UML notation, and show how the conceptual model accommodates the COM+ and Enterprise Java Beans component models. The presentation style will be a mix of lecture, directed exercises, reflection and discussion. After the tutorial attendees will understand the differences between an object and a component, the various forms a component can take, the relationship between these forms and UML concepts, and be able to model components that map to both COM+ and EJB. Attendee Background: Attendees should have experience of object modeling with UML and some knowledge of the principles behind distributed object systems and/or component technologies. John Daniels is a Product Architect at Sterling Software. Prior to joining Sterling he was Application and Technical Architect for Bankers Trust in London, and previously 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. John Cheesman is a Product Architect at Sterling Software. He joined Sterling Software (then Texas Instruments Software) in 1993 and has applied component concepts, methods and standards within their tools. He was a contributor to the Unified Modeling Language, and also worked at Microsoft on their repository and information model design project. Prior to joining Sterling Software, John worked with artificial intelligence, PCTE repository technology and software engineering environments. |
| 33 | Patterns for Mapping Objects to Relational Databases Joseph W. Yoder, The Refactory Inc. |
Colorado Convention Center - A112 |
| For developing simple client-server applications, VisualAge provides a visual language for generating the mappings of GUI's to database values and domain objects. For complex applications, tools such as 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 how to develop a data access layer along with the design patterns used in the database tools provided by persistent managers such as those in VisualWorks, VisualAge, and TopLink. 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". Joe is also studying and writing design patterns for developing reusable software and domain specific languages. |
| 34 | Microsoft COM and DNA - Building Distributed and Component-based Software Michael Stal, Siemens AG |
Colorado Convention Center - C104 |
| With DNA (Distributed interNet Applications Architecture) Microsoft provides an architectural vision how to develop mission-critical software systems on Windows platforms. Applications are built as Multi-tier architectures where all tiers are tightly connected using COM (Component Object Model) as the universal glue. The presentation tier and the middle tiers are not structured as monolithic units but are partitioned into components. The collaboration of components and applications is handled by COM. In the future, even Windows itself will be accessible using the uniform COM programming model. This tutorial will examine the architectural concepts behind Windows DNA and Microsoft COM. It will give an detailed overview of Microsoft COM and related technologies such as Automation, DCOM, OLE-DB, MTS, MSMQ and COM+. Small examples will be used throughout the tutorial to illustrate programming issues. It is the goal of the tutorial to introduce the basic concepts behind Microsoft COM and Windows DNA as well as advanced issues. Attendees will learn how to design and build COM-based applications using object-oriented programming languages such as C++ or Java. They will also get a background in technologies such as Microsoft Transaction Server, MSMQ, OLE-DB.
Attendee Background: Participants should be familiar with object-oriented concepts and object-oriented programming languages, especially C++ or Java. Basic knowledge in distribution technologies is not required but helpful. Michael Stal is responsible for the research project NEST (Net-enabled Software Technology) at Siemens AG in Munich. His main research areas are Object-Orientation, Distribution, Design Patterns, and Java. He is co-author of the book "Pattern-Oriented Software Architecture - A System of Patterns", Wiley & Sons, 1996. He is editor of Java Spektrum, a German SIGS magazine on Java. Michael is member of the Object Management Group and President of the International Java Club. |
| 36 | Analysis Patterns: Reusable Business Object Models Martin Fowler, Independent Consultant |
Colorado Convention Center - C106 |
Attendee Background: Attendees should have a working knowledge of OO analysis and design using the UML Martin Fowler has spent over a decade to applying object technology to business information systems. He is an independent consultant who trains and mentors his clients in OO analysis, design and programming, patterns, and refactoring. He is the author of "UML Distilled" and "Analysis Patterns" which is the source for the patterns in this tutorial. |
| 55 | Software Building - The Road to a Software Architecture Worthy of the Name Kevlin Henney, QA Training Alan O'Callaghan, De Montfort University |
Colorado Convention Center - C107 |
| The notion of non-trivial systems having software architectures is one that is gaining ground. But what is architecture? How can it be defined? More importantly how do you go about creating a software architecture that can be maintained successfully over the lifetime of a potentially long-lived system, and what are the organizational, social and process implications of generating such an architecture? What roles are played by layers, frameworks, patterns and components? This tutorial draws on the experience of both the building construction and software development industries to provide some answers to these questions.
The tutorial is intended to arm the participant with both philosophical and practical notions of software architecture that will enable them to engage in the generation of appropriate software architectures for the problems they have to solve as a computer professional.
Kevlin Henney is a Principal Technologist with QA Training in the UK. His broad area of specialization is OO design, which he has been applying for over nine years across networked, multi-threaded, real-time, GUI and engineering applications. The key areas of specialization and interest that stem from this are patterns, languages, distributed object systems, architecture and component system design. Alan O'Callaghan is a Senior Lecturer at De Montfort University in the UK, chair of its Object Engineering and Migration group and a researcher in its Software Technologies Research Laboratory. He has edited two books on OT adoption, is a featured columnist on migration issues for the European software development journal Applications Development Advisor and is the lead author of the ADAPTOR pattern language. |
Tuesday Full Day
| Software patterns are a literary form, designed to communicate expert knowledge about system construction. This course teaches pattern-writing skills in the context of the broader goals and values of the pattern community. The course mixes lecture with exercises and small workshops. Each participant will write a pattern and participate as an author in a writer's workshop. This innovative tutorial is held over two days so that participants are immersed in the activity and culture of pattern writing.
Attendee Background: A basic software design background is helpful, but not necessary, to fully benefit from the workshop. We encourage attendance by individuals with diverse backgrounds, including (especially!) areas outside computer science. Jim Coplien is a Distinguished Member of Technical Staff at Bell Laboratories in Naperville, Illinois. He is the author of the "Software Patterns" management briefing and co-editor of several pattern books. Richard Gabriel is author of "Patterns of Software," and holds an MFA in Poetry from Warren Wilson College. He is well-known in the pattern community for introducing the writers' workshop format for pattern review. Christa Schwanninger is a software engineer at Siemens Corporate Technology in Munich where she works on distributed applications. She has done pioneering work in patterns for compiler construction and language design. Honna Segel works for Nortel Networks in the development of advanced services. She has both used and developed various apsects of object-oriented technology and has led workshops at OOPSLA in domain analysis and framework development. |
| 37 | Applying Patterns to Support High-performance, Real-time Middleware and Applications Douglas C. Schmidt, Washington University, St. Louis |
Colorado Convention Center - C103 |
| Middleware is becoming increasingly important for building flexible communication systems and reducing software development cycle time. However, conventional implementations of middleware like CORBA, DCOM, and Java RMI lack performance optimizations required by distributed real-time systems. This tutorial describes the principles and patterns necessary to develop high-performance and real-time middleware and applications that can meet end-to-end Quality of Service (QoS) requirements for communication systems.
The objective of this tutorial is to illustrate via real-time use-cases and examples, how to apply patterns and framework components to design and optimize (1) middleware QoS programming models, (2) middleware architectures that minimize priority inversion and non-determinism, associate client requests with servants in constant time, and implement standard middleware protocols, such as GIOP/IIOP, using small memory footprints, (3) middleware scheduling and events services for adaptive QoS and static/dynamic real-time scheduling, and (4) middleware services that control and manage multimedia streaming applications and real-time embedded systems. Attendee Background: The tutorial is intended for software developers who are familiar with general OO design and programming techniques (such as design patterns, modularity, and information hiding), fundamental OO programming language features (such as classes, inheritance, dynamic binding, and parameterized types), basic systems programming concepts (such as process/thread management, synchronization, and interprocess communication), and networking terminology (such as client/server architectures and TCP/IP). Dr. Schmidt is Director of the Center for Distributed Object Computing and an Associate Professor of Department of Computer Science and the Department of Radiology at Washington University in St. Louis, Missouri, USA. Dr. Schmidt is an internationally recognized expert on distributed object computing middleware, patterns, and communication frameworks and has published widely in top IEEE, ACM, IFIP, and USENIX technical conferences and journals. |
| 38 | XML and OO Paradigms Neel Sundaresan, IBM Research |
Colorado Convention Center - C108 |
| XML is the next big revolution in for the World-Wide-Web. As Java greatly impacted distributed programming and web browsing, XML will carry the web to the next phase of e-commerce, internet based document exchange and workflow. XML forms the static aspect of the future of the Web, while Java and OO paradigm form the dynamic aspects.
XML (unlike HTML) is an extensible tag language with three main aspects: extensibility, structure, and schema validation. XML also separates content from schema, processing, and semantics, thus following the Model-View-Controller (MVC) paradigm prevalent in OO programming. As XML is being seamlessly integrated into Web and non-Web applications, a number of XML processors are becoming available. Also, as XML specifications are integrated into programming languages, component models like bean architectures become important. A number of design patterns also are supported to enable XML structures to blend with OO application architectures. This tutorial will cover aspects of processing XML in using OO paradigms, integrating them with user applications, using design patterns to add power to this integration, and building application components. Attendee Background: The tutorial is targeted at students, developers, and architects. Participants should have working knowledge of Java, and OO systems. Dr. Neel Sundaresan is a Research Staff Member at the IBM Almaden Research Center. He is a member of the Web Technologies Group and is a lead architect of the Grand Central Station Project -- A Large Scale Programmable and Extensible Web Information Gathering System, and also leads research efforts in XML and OO Technologies. He has over 20 publications in the area of Programming Languages, Compilers, High Performance Computing, Distributed Systems and Internet Technologies, Database systems, and OO Paradigms. |
| 39 | Effective Strategies and Techniques for Rapid Object-Oriented Application Development Michael P. Anton, Financial Technology Solutions Inc. |
Colorado Convention Center - C102 |
| 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, programming and even to the team organization.
By the end of the tutorial, participants will not only learn about, but also experience and help to build a Web-based software system, taking it from concept to a functional prototype in only a day. Attendee Background: This tutorial will assume and build on the participant having a good familiarity with Object Modeling, UML notation, the general concept of Patterns and Pattern Languages, and at least one year experience programming in an Object-Oriented language. Michael Anton is a Senior Management Consultant at Sanford Bernstein & Co., Inc., an Investment Management and Research Firm in New York City. He 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. Mr. Anton has been involved in Object-Oriented Development for eleven years and has contributed to dozens of projects in portfolio management & trading, molecular modeling, directional drilling, traffic control, office automation, Microwave CAD and interactive voice response. |
| 40 | The Cost Estimation, Bidding and Quantitative Process Management of Component Based Software Development Projects Philip Haynes, Object Oriented Pty. Ltd. |
Colorado Convention Center - A102 |
Attendee Background: This course is targeted towards seasoned professionals responsible for the estimation, bidding and delivery of OO projects. Attendees should have significant industry experience in OO project management, component architectures or OO process management. Philip Haynes is a Principal Consultant and Program Manager with Object Oriented Pty. Ltd. Since 1994 he has worked on estimating, bidding and delivery of fixed priced software projects. Mr. Haynes has also been actively researching and applying quantitative OO process management technologies in an industrial context and has written number of papers on software quality management and quantitative approaches to software development. Mr. Haynes was a workshop organizer for the 1996-1998 OOPSLA OO Metrics and Cost Estimation Workshops. |
Tuesday Morning/Half Day
| 18 | Evaluating Object Transaction Monitors Ian Gorton, CSIRO |
Colorado Convention Center - A104 |
| This tutorial aims to give software architects, engineers and researchers a detailed appreciation of the relative strengths and weaknesses of object-oriented middleware technology for distributed transaction processing (DTP). These products are known as Object Transaction Monitors (OTMs).
The tutorial aims will be achieved by addressing the following specific objectives:
Attendee Background: A basic understanding of objects and middleware technology such as CORBA, Java RMI, DCOM and/or DCE. Ian Gorton has worked as a software engineer in both research and commercial roles for the last 10 years. Until recently, he was Consulting Services Manager for IBM Transarc in the Asia-Pacific, acting as a distributed systems architect on a number of projects for major clients. Before that he has worked as a consultant for Microsoft Australia, and as a senior academic at the University of New South Wales in Sydney, where he still holds a visiting academic position. Ian recently joined CSIRO CMIS to establish a new R&D group in the area of software engineering for distributed systems. He is currently writing a book on OTMs for Addison-Wesley. |
| 42 | The Art of Writing Use Cases Rebecca Wirfs-Brock, Wirfs-Brock Associates Alan McKean, Wirfs-Brock Associates |
Colorado Convention Center - A106 |
| Use Cases describe a software system from an external usage perspective. There is an art to writing them clearly. Written carefully, use cases convey key usage requirements and can be tied to other requirements. Written poorly, use cases are confusing and ambiguous. This tutorial presents examples of both good and bad Use Case descriptions drawn from real projects, and practical techniques for writing three forms of use case descriptions. We begin with brief textual descriptions written from an external perspective. We elaborate these high-level usage descriptions, choosing either a scenario form, which emphasizes sequence, or a conversation, which highlights interactions between a user and the system. Tips for describing policies, errors and exceptions, and glossary entries are also presented. This is a hands-on tutorial. Attendees will practice writing, critically reading and revising usage descriptions.
Participants will be able to apply principles and writing techniques to their own projects, writing appropriate usage descriptions. Attendee Background: Students should be familiar with writing and reading informal 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 pre-requisite! 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 Tek's development of Color Smalltalk. She has 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 and co-author of the classic, "Designing Object-Oriented Software." Alan McKean, Vice President of Training at Wirfs-Brock Associates, 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. |
| 43 | Transaction Processing with Objects Rajendra K. Raj, Morgan Stanley Dean Witter & Co. |
Colorado Convention Center - A108 |
| The design, development and deployment of robust enterprise-wide transactional applications continue to be difficult. This tutorial provides an introduction to Object Transaction Processing (OTP) concepts, which are essential to the construction of such applications. The tutorial presents traditional transaction processing (TP) concepts and systems, discusses the impact of object technology on TP, develops a set of techniques to evaluate OTP approaches, and compares the current approaches and implementations of transaction processing with objects. Using specific real-world case studies, these techniques are applied to several illustrative OTP systems based on commercial products such as Microsoft Transaction Server, and implementations of OMG's Object Transaction Service and Enterprise JavaBeans.
Participants will learn general concepts underlying transaction processing with objects. They will be introduced to the design and development of OTP systems. Participants will also be exposed to the current state of commercial OTP technology and criteria that may be used for comparative evaluation of object transaction monitors. Attendee background: Participants should have participated in the construction of object-oriented programs. Some understanding of database systems is useful, but not required. Rajendra K. Raj is Vice President in Institutional Information Technology at Morgan Stanley Dean Witter, where he led the development of several generations of transactional distributed financial object infrastructures. Dr. Raj was previously an Assistant Professor at SUNY Oswego. He received his Ph.D. from the University of Washington, Seattle. |
| 44 | Introduction to Concurrent Object-Oriented Programming in Java Doug Lea, SUNY Oswego David Holmes, Microsoft Research Institute |
Colorado Convention Center - A110 |
| Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support of concurrency has enticed many to try their hand at concurrent applications. Effectively creating and managing concurrency within an application poses many design choices and trade-offs. This tutorial looks at more advanced issues in designing concurrent applications. It describes mechanisms for introducing concurrency into applications (threads, message-passing, asynchronous calls) and different models for application architectures, such as data-flow and event- driven designs. The tutorial also shows how concurrency controls can be abstracted into reusable support classes, and finally discusses how concurrent components and applications should be documented.
Participants will learn how concurrent applications can be structured in different ways and how different mechanisms can be used to effect concurrent behavior. They will be exposed to a range of design patterns and techniques for introducing and managing concurrency within their applications and how to create reusable concurrency abstractions. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is expected that the attendee is very familiar with OO concepts and the Java language, and that they have a good working knowledge of Java's concurrency mechanisms. David Holmes is a Ph.D. student with the Microsoft Research Institute at Macquarie University, Sydney, researching more adaptable, flexible and re-usable approaches to synchronization in concurrent object-oriented programs. He has a degree in Computer Systems Engineering and practical experience with concurrent programming through work on operating systems, distributed systems and real-time embedded systems, within a university environment. Doug Lea is a Professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. |
Subject-oriented programming (SOP) is a practical approach to object-oriented (OO) programming-in-the-large. SOP addresses some well-known limitations of OO development, without forcing developers to adopt new languages or abandon the OO paradigm, including weaknesses in:
This tutorial presents SOP and shows participants how to use it, both conceptually and using tool support. It also briefly contrasts SOP with other related approaches (e.g., AOP), to aid participants in selecting the best approach for a given problem. Participants will learn to identify and address, using SOP, some difficult and pervasive problems in their OO development activities. They will also learn how SOP promotes the use of design patterns, frameworks, and reusable components. Attendee Background: Familiarity with OO concepts and design patterns, and at least some experienced in developing OO applications, are required. Harold Ossher co-invented subject-oriented programming in 1993. He manages a group that has built tool support for SOP in C++ and prototype support for Smalltalk, and conducts related research. Peri Tarr has a strong background in software engineering and the application of subjects to it. She leads the tool development effort for subject-oriented programming in Java and has been exploring issues in subject-oriented software engineering throughout the software lifecycle. |
| 46 | Meta-Classes in C++ - Reflection for Existing Classes Detlef Vollmann, Vollmann Engineering |
Colorado Convention Center - C107 |
| Reflection is a programming technique for object-oriented architectures to provide better extensibility of a system (especially at run-time) and a means of providing 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, thus forcing an unnatural style of programming. This tutorial presents some lesser known C++ constructs that can be used to provide meta-class 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++.
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 the Swiss Digicomp AG. |
| 47 | Exploring the Unified Modeling Language by Example Charles Richter, Objective Engineering, Inc. |
Colorado Convention Center - A109 |
| The Unified Modeling Language has emerged as a standard for object-oriented analysis and design notation. Because it attempts to provide notation for most aspects of object-oriented design, however, UML is a rich and complex language offering several types of diagrams. This tutorial uses the design of a small problem to explore many of UML's more advanced features, including use case diagrams, activity diagrams, and the notation for concurrency and distribution. Upon completion of this tutorial, attendees should have a deeper understanding of the UML and its application to real, everyday problems. Attendees will also be exposed to some of the more advanced and unusual features of the UML.
Attendee Background: This tutorial is aimed at developers who have at least a rudimentary knowledge of the Unified Modeling Language (UML) notation and are interested in a more detailed understanding of the application of that notation. The tutorial assumes the attendee understands basic object-oriented concepts such as classes, inheritance, and polymorphism, as well as the basic object-oriented modeling and design constructs such as class diagrams (object models) and object interaction diagrams. Charles Richter has been involved in object-oriented development for over ten years, and has been teaching object-oriented design for most of that time. He has considerable development and teaching experience with several design methods and notations, including UML. He is the founder and a principal of Objective Engineering, Inc., a company dedicated to providing quality training and consulting in object-oriented analysis and design and in Java programming. |
| 48 | An Introduction to Design Patterns John Vlissides, IBM T.J. Watson Research |
Colorado Convention Center - A201 |
| 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.
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 C++ is recommended. John Vlissides is a member of the research staff at the IBM T.J. Watson Research Center in Hawthorne, NY. He has practiced object-oriented technology for over a decade as a designer, implementer, researcher, lecturer, and consultant. John 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. |
| 49 | Automating Software Testing in Java using Beans and Reflection Nigel Bakker, Software Futures Chris Nel, Futureworks |
Colorado Convention Center - C109 |
| 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. We explore techniques for simplifying testing. A common OO software testing approach uses harnesses or test classes to exercise the classes under test. This approach has a number of problems and limitations. We contrast this with a framework that uses Beans and Reflection for automating unit testing. We also show how to extend the framework for automating functional testing through test cases. A combination of slides and demonstrations are used to build from basic concepts through to actual implementation.
Attendees will learn about testing concepts, the Java Reflection API and the Java Beans specification as applied to automated unit testing. They will be shown how black box, and to a lesser extent, how white box testing can be automated by exploiting built in language features. 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 Software Futures in the area of Object Technology. He has had over 13 years of software development experience, including eight years applying Object Technology in applications ranging from banking systems to embedded controller and communication systems. He has recently been asked to author a column for the online publication ITWeb. ( http://www.itweb.co.za ) Chris Nel has more than 10 years experience in software development; Including analysis, design, implementation and testing thereof. Chris is involved on a daily basis with cutting and testing code. |
| 51 | Structuring Object-Oriented Software Development Project Teams in Support of System Architectures Luke Hohmann, Aurigin Systems, Inc. |
Colorado Convention Center - C106 |
| Conway's law tells us that the structure of the system is strongly influenced by the organizational structure of the team that builds it. Proper partitioning of object-oriented systems dictates a well thought out distribution of responsibilities among subsystems. Unfortunately, traditional approaches to team structure do not effectively support the adoption or use of object technology, for they do not adequately address the unique features of well-designed object-oriented system architectures. Upon attending this tutorial, the participant will be able to: describe architectures for object-oriented applications; define how to control growth within teams; define organizational structures and their usefulness in object-oriented projects; design organizational structures that support object-oriented development; determine if mentors or consultants are appropriate for their project; establish roles and responsibilities among team members.
Attendee Background: This tutorial is designed for those individuals responsible for managing an object-oriented project. A participant should understand basic concepts of object technology (e.g., class vs. instance, polymorphism, encapsulation). Prior project management experience is helpful, but not required. Luke Hohmann is Vice President of Engineering at Aurigin Systems, Inc. Mr. Hohmann has extensive experience in object-oriented analysis and design, software engineering, user interface design, and project management. He is the author of "Journey of the Software Professional: A Sociology of Software Development" (Prentice Hall). Mr. Hohmann is currently working on two books, "GUIs with Glue: Creating Usability Through Lo-Fi Design" and "Mastering Software Patterns in C++". Mr. Hohmann has a B.S.E. in Computer Engineering and an M.S.E. in Computer Science and Engineering from the University of Michigan. |
Tuesday Afternoon/Half Day
| 53 | The Unified Process and Beyond Ivar Jacobson, Rational Software |
Colorado Convention Center - A110 |
| A better development process-in fact, a process unifying the best practices now available-is the key to the software future. The proven Unified Process originally developed by Ivar Jacobson, now incorporating the work of Grady Booch, Jim Rumbaugh, Philippe Kruchten, Walker Royce, and other people inside Rational, answers this long-felt need.
Component and object based, the Unified Process enables reuse. Use-case driven, it closes the gap between what the user needs and what the developer does. Architecture centric, it guides the development process. Iterative and incremental, it manages risk. Represented in the design blueprints of the newly standardized Unified Modeling Language (UML), it communicates your results to a wide audience. However, now we may ask ourselves the question: Is the Unified Process a framework on which the future can build, or will there be a new paradigm that force us to start over? This innovative tutorial combines lecture with a question and answer format, to allow students to ask questions specific to their needs or areas of interest. The questions can be submitted in advance (details available at http://canuck.gda.itesm.mx/~almarode/tweb/tutorial53.html) and will be filtered and organized by a person chosen to spur debate and raise issues. Students will also be able to submit questions during the tutorial, for discussion during the second half. This tutorial promises to be very interactive and tailored to the students needs. Attendee Background: The attendees are expected to have experience in software development and some background in object technology. Dr. Ivar Jacobson is vice president of business engineering for Rational Software Corporation. Dr. Jacobson is the founder of Objectory AB in Sweden, which merged with Rational Software in 1995. He was one of the three original designers of the UML (Unified Modeling Language), which was officially adopted as a standard by the Object Management Group (OMG) in 1997. He is the principal author of three influential and best-selling books: "Object-Oriented Software Engineering-A Use Case Driven Approach", "The Object Advantage-Business Process Reengineering with Object Technology", "Software Reuse: Architecture, Process, and Organization for Business Success", "The Unified Software Development Process" |
| 54 | Designing Concurrent Object-Oriented Programs in Java David Holmes, Microsoft Research Institute Doug Lea, SUNY Oswego |
Colorado Convention Center - A106 |
| Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support of concurrency has enticed many to try their hand at concurrent applications. However concurrent programming poses many traps for the unwary. This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side we look at Java's mechanisms to support concurrent programming. On the design side we look at object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems. Participants will acquire comprehensive knowledge of the concurrency support provided by the Java language and core classes, as well as insight into some threading issues within the Java libraries. They will be exposed to a range of design approaches to assist them in developing safe, concurrent, applications in Java and other object-oriented languages.
Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is assumed that the attendee is familiar with basic OO concepts and has a working knowledge of the Java language. David Holmes is a Ph.D. student with the Microsoft Research Institute at Macquarie University, Sydney, researching more adaptable, flexible, and reusable approaches to synchronization in concurrent object-oriented programs. He has a degree in Computer Systems Engineering and practical experience with concurrent programming through work on operating systems, distributed systems and real-time embedded systems, within a university environment. Doug Lea is a Professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns", co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. |
| 56 | Interconnecting Objects via Contracts Luis Andrade, Oblog Software SA Jose Fiadeiro, University of Lisbon |
Colorado Convention Center - C107 |
| Even if mechanisms are provided for capturing and integrating behavioral aspects in system models, object-oriented approaches have not yet produced primitives and constructs for treating interactions as first-class citizens. Interactions between objects in a system are too often coded in the way messages are exchanged and methods are called, making it difficult to understand and evolve the discipline that governs the interaction between different components of a system without a deeper analysis of the way objects are designed. Yet many application domains, like banking, require high levels of reconfigurability of existing services, e.g. new ways for clients to interact with their bank accounts. This suggests that an explicit model of the coordination that is required between the different components in the system should be given immediately at the level of the domain model.
This tutorial puts forward the concept of contract as a mechanism for providing explicit representations of interconnections between objects. The usefulness of the concept is illustrated with examples taken from real-life projects. Finally, we show how contracts can be realised both in UML-like languages and ORBs. Attendee Background: Familiarity with object-oriented conceptual modeling and architectural design is useful. Luís Andrade is partner and Technical Vice-President of Oblog SA in Portugal and Oblog Technology Inc. in the USA This company has developed a sophisticated object-oriented specification language (OBLOG) and its supporting tools. He is also partner and president of a software company with extensive experience in developing banking applications and tools based on the Oblog language. José Fiadeiro is Professor for Computing Science at the University of Lisbon. 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. He has published more than 70 papers in these areas. He has also co-authored and presented a tutorial on the formalization of object-oriented modeling techniques at OOPSLA'94. |
| 57 | Balancing Architecture Design Alternatives Based on Adaptability, Reuse and Performance Factors Mehmet Aksit, CTIT, University of Twente |
Colorado Convention Center - C109 |
| Software systems have to cope with continuously changing requirements. If a software system is derived from a well-defined architecture specification, the effect of changes in the requirement specification will be limited to the boundaries of the abstractions of the architecture. Since architecture specifications are generally abstract, one may create different implementations for the same architecture specification. Each alternative implementation will have different adaptability, performance and reusability characteristics. Providing ultimate adaptability may create too much run-time overhead. Aiming at the fastest implementation may result in unnecessarily rigid software. Aiming at the most reusable software may introduce redundant abstractions for a given problem. Software engineers, therefore, must be able to explicitly compare, evaluate and decide on various design alternatives of architectures based on the relative importance of the quality factors. This tutorial teaches techniques to depict the space of alternative implementations of architectures, and rules to select among the alternatives using quality factors. An example problem will be worked out and its various design and implementation alternatives will be demonstrated on a notebook computer.
The participants will learn techniques to depict the architectural design space, to balance adaptability, reuse and performance factors, and to select among design alternatives. Attendee Background: Some knowledge of software architectures and programming languages is required. Mehmet Aksit is working as an associate professor at the University of Twente. He gave more than 60 international and in-company courses in Europe, USA and Canada. Dr. Aksit has been the user and developer of object-oriented systems since 1983. He has been involved in designing architectures for several large industrial projects. |
| 58 | Distributed Object Programming using Java and CORBA Nigel Bakker, Software Futures |
Colorado Convention Center - A104 |
| Today's computing paradigm of "The Network is the Computer" has fundamentally changed the way we build applications. Java has been a powerful force for change in this regard. Compliment Java with CORBA and this type of solution is likely to become ubiquitous. The tutorial will introduce CORBA basics and demonstrate their implementation using Java. The tutorial will also introduce some common CORBA design patterns and other useful tips and tricks for overcoming some of the difficulties with distributed object applications. Finally, CORBA is briefly contrasted with RMI and DCOM/COM+.
Attendees will learn about distributed object concepts and how distributed applications are built in Java with CORBA. They will be introduced to some of the common problems encountered in this domain and shown how these problems can be overcome. Attendee Background: A working knowledge of Java is essential. Some experience with object modeling would be useful since some of the design elements are presented using the UML. The material is intended for developers and architects who would like to learn more about CORBA and come to grips with some of the issues related to building distributed applications using CORBA and Java. Nigel Bakker is a Senior Consultant in Object Technology at Software Futures. He has had over 13 years of software development experience, including eight years applying Object Technology in applications ranging from banking systems to embedded controller and communication systems. He has recently been asked to author a column for the online publication ITWeb. ( http://www.itweb.co.za ) |
| 59 | Storing Java Objects and Enterprise JavaBeans in Relational Databases Dennis Leung, The Object People |
Colorado Convention Center - A106 |
| 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 are using 3 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. Attendee Background: Participants should have a basic knowledge of Java, object modeling and relational database. A high level knowledge of Enterprise JavaBeans would also be of use for the sections focused on EJBs. Dennis Leung is the Manager of Product Development 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. |
| 60 | Advanced Project Management Kenny Rubin, Secant Technologies, Inc. |
Colorado Convention Center - C106 |
| Software development projects have to be managed properly to obtain the most benefits from object-oriented technology. To meet and exceed project goals, issues surrounding planning and control, team structure, software development environment, methodology, reuse, quality assurance and measurement must be understood and addressed. This presentation discusses advanced aspects of these issues by examining the details of a particular software development project that created a high-quality, shrink-wrapped software product.
Attendee Background: Attendees should be project managers or should have an interest in project management. Experience managing on one or more object projects would be helpful. Mr. Rubin is Chief Operating Officer of Secant Technologies, Inc., a leading provider of advanced software technologies for assembling, deploying and managing scalable, multi-tier applications. Previously he was Director of New Business Development in the IBM North America Object Technology Practice. Prior to that, Mr. Rubin was Manager of Methodology Development and Manager of Professional Services at ParcPlace Systems, Inc. He is the co-author of the popular book Succeeding with Objects: Decision Frameworks for Project Management. Mr. Rubin received his BS. in Information and Computer Science from the Georgia Institute of Technology and his M.S. in Computer Science from Stanford University. |
| 61 | Designing with Patterns John Vlissides, IBM T.J. Watson Research |
Colorado Convention Center - A201 |
| Design patterns are making the transition from curiosity to familiarity. Now that many people know what they are, they want to know how best to apply them. This tutorial shows how to leverage patterns in the software design process. It reveals the thinking behind pattern application; including when not to use a seemingly applicable pattern. It shows how the right patterns can improve a design and how the wrong patterns can degrade one. Students thus learn to apply design patterns to maximum benefit.
Attendee Background: Attendees should be well-grounded in object technology and should be familiar with the design patterns in Design Patterns: Elements of Reusable Object-Oriented Software, by Gamma, et al. Familiarity with Java is recommended. 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. |
| 62 | Extending the C++ Standard Template Library (STL) Jan Christiaan van Winkel, AT Computing |
Colorado Convention Center - C111 |
| When writing applications in C++, STL - the Standard Template Library 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 if 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. Attendee Background: The attendees are expected to know C++ and normal use of STL. JC 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 are published as a book by the Dutch publisher ``Academic Service''. He is the Dutch representative in the ISO C++ standardization committee SC22/WG21. |
| 63 | Designing A Light Methodology Alistair Cockburn, Humans and Technology |
Colorado Convention Center - A109 |
| This tutorial is for experienced developers, team leaders, methodologists selectors trying to design a methodology for their organization. The attendee should have significant software team experience, not necessarily OO, must have used at least one methodology and thought about others. 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, optimized for productivity, making maximum use of human, face-to-face communication. Considerations about success and failure in affecting culture are visited again at the end. Learn to identify and diagnose the parts of your organization's methodology, and learn ways to make it more effective.
Attendee Background: This tutorial is for experienced developers, team leaders, and evaluators of methodologies. 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. 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 . |
Wednesday Full Day
| 1 | Introduction to the Rational Unified Process Philippe Kruchten, Rational Software |
Colorado Convention Center - C109 |
| The Rational Unified Process is a Software Engineering Process. It provides a disciplined approach to assigning tasks and responsibilities within a development organization. Its goal is to ensure the production of high-quality software, that meets the needs of its end-users, within a predictable schedule and budget. The Rational Unified Process captures many of the best practices in modern software development in a form that is suitable for a wide range of projects and organizations. It uses the Unified Modeling Language (UML) as the principal notation for the several models that are built and refined during the development.
The objectives of this tutorial are to introduce the Rational Unified process, to explain its architecture and representation, and to show some of its benefits. The attendance will learn how to structure a software engineering process using an object-oriented approach. They will see how the process makes an extensive use of object-oriented models, all based on the UML, throughout the lifecycle. They will be shown the merits of an iterative approach, focusing first on the development and validation of a robust architecture. And finally they will be taken for a guided a tour through this interactive, web-enabled knowledge base. Attendee Background: Software development managers, software developers, process engineers; no special background or pre-requisite is necessary. Philippe Kruchten is director of process development at Rational Software Canada, currently in charge of the Rational Unified Process, and a member of the Rational Architecture Practice Group. |
| 41 | Object-Oriented Distributed Computing: From Theory to Practice Mohamed E. Fayad, University of Nebraska, Lincoln |
Colorado Convention Center - A202/204 |
| The tutorial presents a complete overview of theoretical issues in the Distributed Computing field, such as the Type-Oriented Paradigm (TOP), Concurrency, Loosely-Coupled Systems, and CORBA Issues and discusses how to move these theoretical concepts smoothly into practice. This tutorial discusses several key technologies for the success of distributed system development projects, such as application frameworks, component-based development, agents, design patterns, business objects, framework layering, and others. The OODC is examined with respect to two central themes: "What are the right steps in the development of an object-oriented distributed system?" and "How can you start a large-scale distributed system development with minimum risks?" The information in this tutorial is based upon lessons learned from the research and development of "Philips New York Project: a Large Scale Distributed Healthcare System using CORBAmed." This tutorial is targeted to those individuals interested in distributed computing, distributed real-time system developments and client-server application issues.
Attendee Background: Participants should have a general familiarity with basic object-oriented concepts and software engineering principles. Mohamed Fayad is an Associate Professor at University of Nebraska, Lincoln. He has been actively involved in over 60 OO projects. Dr. Fayad is an Associate Editor and Columnist (CACM), Editor-In-Chief (IEEE-CS 95-97), a distinguished Speaker (IEEE-CS). Dr. Fayad is the lead author of "Transition to OO Software Development" with M. Laitinen, Wiley, 1998. He is also the lead author of the three-volume book on Application Frameworks, with R. Johnson and D. Schmidt, Wiley, 1999 and "OO Enterprise Frameworks" with D. Hamu, 1999. |
Wednesday Afternoon/Half Day
| 13 | The Manager's Role in a Successful Transition to Object-Orientation Norm Kerth, Elite Systems |
Colorado Convention Center - C202/204 |
| Object-oriented thinking is just the latest of many technologies promising to improve software development. We hear claims such as increased productivity, higher quality, extendibility, reuse and portability. Whether these claims remain as dreams or are actually realized is dependent on the manager's ability to guide their organization to new effective uses of this technology. The pressure to participate in the internet and use the new UML standard only adds to the importance of the manager's role.
This tutorial discusses what managers should expect and need to do as their organization grows in its maturity to use objects. It is a course loaded with wisdom and experience. In this tutorial, you learn how to develop a management program that allows you to introduce this new technology. It explores the appropriate deployment of the technology as well as the management issues - people-oriented as well as project-oriented - that must be attended to. The tutorial takes the view that the transition is a long-term project and discusses a manager's role over a many year period. It pays special attention to the process by which people work through a paradigm shift. Attendee Background: No specific background required. Norm Kerth is a consultant working with companies interested in ensuring that they make a successful transition to using the object-technologies. He includes the wider issues of specification and design activities, quality assurance, continuous process improvement, project management and building effective teams. Prior to starting his company, Elite Systems, he was a professor and researcher at the University of Portland. He has a decade of engineering experience with Tektronix and is a master teacher, with over 25 years of experience in front of students and computer professionals. |
| 64 | Precise Component Architectures with UML/Catalysis Desmond D'Souza, Platinum Technology Ian Maung, Platinum Technology |
Colorado Convention Center - A101 |
| The word "architecture" bestows instant importance to loose powerpoint drawings. But components will only plug together if they conform to shared "pluggable" architecture standards. Believing "architecture keeps designers from needless creativity", we present a clear definition of architecture based on UML packages, frameworks, and refinement. Elements and rules of an architectural style are separated from the design which use them. Components architectures use an abstract component-connector model, simplifying the development process in the Catalysis/CBD approach to UML.
Participants will learn to:
Attendee Background: Attendees should be familiar with OO modeling and design patterns. Desmond D'Souza is VP of component-based development at Platinum Technology, co-author and developer of the Catalysis method for systematic development of business-driven component systems, published by Addison Wesley. Ian Maung is Component Architect at Platinum Technology, developed the full CBD/Catalysis process for UML, and has worked with rigorous methods applied to object modeling since 1989. |
| 65 | Improving the Performance of Persistent and Distributed OO Applications Ashutosh Tiwary, University of Washington Przemyslaw Pardyak, University of Washington |
Colorado Convention Center - A103 |
| High-performance and scalability are hard to achieve in persistent and distributed object-oriented applications because of their inherent complexity. Developers are often unaware of the trade-offs and design choices that are critical to achieve the desired performance. In this tutorial, we discuss how to design and implement such applications for better performance. We describe performance issues faced by the developers and the design decisions that promote high performance. We present guidelines for evaluating the performance of architectural and design alternatives and describe tools and techniques used for such evaluations. Finally, we present three real-world case studies of performance evaluation of persistent and distributed OO applications.
Participants will learn about the major performance issues and design trade-offs in building persistent and distributed object-oriented applications. They will learn how to evaluate the performance of alternative system architectures, application designs, and infrastructure choices. They will also learn what tools and techniques to use for such evaluations. Attendee background: This tutorial is targeted towards individuals who are engaged in or are considering building and deploying persistent or distributed object-oriented applications. We expect the attendees to understand the basics of object-oriented concepts, object-oriented languages, object-oriented database systems, and distributed object-oriented systems. Ashutosh Tiwary is a researcher with the Research and Technology Group at Boeing and a Ph.D. Candidate in the Computer Science Department at the University of Washington. His thesis work is focused on performance evaluation and tuning of persistent and distributed OO systems. He was the chair of OOPSLA `95 and `96 Workshops on Building Large Persistent and Distributed Software Systems using Objects. He was also invited to speak at the OOPSLA `98 panel on Experiences in Building Distributed Systems. Przemyslaw Pardyak is a Ph.D. Candidate at the University of Washington doing research on operating systems and performance evaluation. He received a M.S. degree in the area of distributed object-oriented systems and languages. |
| 66 | GOF Pursuit - Learning Patterns by Playing James Noble, Microsoft Research Institute, Macquarie University Charles Weir, Charles Weir Consulting Limited |
Colorado Convention Center - A108/110/112 |
| Design patterns allow us to learn software design from the experience of others. Unfortunately patterns are difficult to learn using conventional techniques, so many designers have only a partial or incorrect understanding of the patterns available.
This tutorial is based around GOF Pursuit, a game based loosely on 'Trivial Pursuit'. This game is effective in helping practitioners learn the patterns in the "Design Patterns" book by the so-called 'Gang of Four' (Gamma, Helms, Johnson and Vlissides). This tutorial will be a hands-on-workshop to help participants learn and re-learn patterns, to teach participants how to organize GOF Pursuit games and to be fun at the same time. This tutorial will enhance participants' design abilities by evaluating their knowledge of design patterns and by consolidating that knowledge, especially of the more complex patterns. Participants will use the techniques of the GOF Pursuit game to learn design patterns in breadth and depth. Attendee Background: This tutorial targets anyone who is using design patterns, who wishes to refine or improve their knowledge of design patterns, or who plans to introduce them to their workplace or teach them to others. It is assumed that the attendee is familiar with OO concepts, and has encountered the design patterns from Gamma et. al. Dr. James Noble is a Research Fellow in OO design at the Microsoft Research Institute, at Macquarie University, Sydney. He has presented and published papers on design patterns in three continents, and has a Ph.D. in Computer Science from Victoria University of Wellington, New Zealand. He established the Sydney Patterns Group, and with Charles Weir, is writing a book of patterns for the Software Patterns Series. Charles Weir has more than fifteen years' experience of working on Software Development projects, providing on-site mentoring to many companies in Europe. Charles has presented sessions on patterns for clients and at conferences, has chapters on Patters in volumes 3 and 4 of the "Pattern Languages of Programming" series. |
| 67 | Object-Oriented Analysis and Design Vladimir Bacvanski, InferData Petter Graff, InferData |
Colorado Convention Center - A105 |
| This tutorial covers the essential and most important aspects of adopting object-oriented analysis and design and is intended to introduce the participants to the process and deliverables in the analysis and design of object-oriented systems. The tutorial teaches a proven method of building software systems from domain analysis to design based on UML and best industrial practices. The course teaches students how to build object models, to understand the business domain, write system operation specifications, and create modifiable designs. To produce the models, we will apply a step by step method that leads the students through the development phases. This method will help establish a seamless path from user requirements to object-oriented code.
Attendee Background: Participants should be familiar with software development or programming. No specific object-oriented experience is required. Dr. Vladimir Bacvanski has over a decade of engineering experience with object-oriented and advanced software technologies. He has published numerous papers including contributions to books, and has been an invited speaker, chair and organizer at leading conferences in the area of object-oriented and knowledge-based systems. Petter Graff has been developing object-oriented systems since 1982. Most of his experience has been in the area of large Distributed Real-Time systems. He has helped Fortune 500 companies revolutionize their software development process. Mr. Graff is a frequent speaker and organizer at conferences, including OOPSLA and TOOLS. |
| 68 | Setting Up a Software Component Factory Peter Herzum, Platinum |
Colorado Convention Center - A107 |
| Component-based development can support high-levels of software development productivity, given an appropriate conceptual framework and a set of pragmatic steps to set-up the development environment and organization. This tutorial describe how to set-up a component factory (i.e., an efficient software production capability able to deliver and assemble industrial-level software components) by presenting the common issues, the architectural principles and the pragmatic steps required for such an endeavor. The tutorial is based on the book "The Business Component Factory", by Peter Herzum (principal author) and Oliver Sims, John Wiley and Sons. Participants will acquire the terminology, principles and steps, as well as being introduced to the main risks, costs and examples of common mistakes, required to approach the efficient production of components, component-based systems and integration of component-based systems for the enterprise.
Attendee Background: The tutorial is targeted to professionals involved in the management, architecture, integration or design of next-generation component-based systems for the enterprise. Prerequisites are a background of software engineering principles for large-scale development and familiarity with the object oriented paradigm. Useful but not required pre-requisites include familiarity with distributed business system development and with the development of data-intensive, transaction-oriented business systems. Peter Herzum has been working with objects since 1987 and with business components for the enterprise since 1992. Currently responsible for the component-based practice at PLATINUM Technology, Inc., he is the creator of the business component approach, an approach centered on components for the efficient development of large-scale distributed business systems. He has architected, mentored and managed very large-scale projects both in Europe and in the US. An active member of the OMG, he is the principal author of the book "Business Component Factory: Theory and Practice". |
| 69 | Building and Using Highly Re-useable and Configurable Frameworks Martine Devos, EDS Electronic Data Systems Michel Tilman, VUB Brussels Free University |
Colorado Convention Center - A109 |
| Object-oriented frameworks aim to capture the commonalities and variabilities of particular classes of applications through techniques such as inheritance and re-usable components. Knowledge about the variations, the common theme and the problem domain is usually buried in the program structures. This makes frameworks often harder to understand, use and test when building and maintaining applications. When we turn this implicit knowledge into explicit specifications, the resulting frameworks often become more concise and elegant. The applications built using the frameworks are easier to change and understand by less experienced developers and even users.
We show that many of these reflective frameworks are less exotic and complex, and easier to develop than is commonly thought. We present examples from existing frameworks and extract concepts, architectural and organizational patterns, and methods that work. We present the advantages and caveats of building a highly-reflective commercial framework, how to bootstrap it, and how to use it. Participants will gain a good understanding of:
Attendee Background: Participants should be experienced in object-oriented design and development. The tutorial is targeted at software architects and technical leads. Martine Devos recently joined EDS as a reuse consultant. Before this she was IS-manager at Argo where she initiated and coordinated the development of a framework and several applications using it. She has organized several workshops and panels at major OO conferences and is conference chair of EuroPlop 99. Michel Tilman started his career at the VUB in the Mathematics Department. In 1985 he joined the Programming Technology Lab, teaching diverse entry-level and advanced courses. His research activities centered on object-oriented frameworks for CSCW applications and the practical use of reflection. As architect of the Argo project he applied these techniques in a commercial environment. |
| 70 | From Components to Java Beans Fintan Culwin, South Bank University |
Colorado Convention Center - A111 |
| The widgets in the Java AWT and JFC collections supply the fundamental components that are required for the construction of standard user interfaces. Many situations require more specialized user interface components to be developed. This tutorial will expose the processes involved in first developing a specialized component and then upgrading it to become JavaBeans compliant. This will be done within the context of designing for usability, and reusability, from the outset.
The objectives of this tutorial are:
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. |
| 71 | Unleashing the Power of Distributed Enterprise Information Systems Trygve Reenskaug, University of Oslo and Numerica Taskon AS Lasse Bjerde, Numerica Taskon AS |
Colorado Convention Center - A106 |
| The goal of this tutorial is to prepare the participant to meet the challenges of the era of distribution by giving a roadmap to the world of distribution.
Communication-centered architecture is the new form of architecture that has extended and replaced earlier architectures. It promises to handle unlimited size and complexity, higher level of reuse through components, and distributed ownership and control. It is surprisingly different and difficult, even though it starts from objects. The difficulties partly stem from specific technologies such as CORBA, RMI, EJB, and transaction monitors. But the main challenge is on a higher level; changing one's mindset from the self-contained application to the idea of collaborating objects working within a vast world of existing components. The tutorial will focus on the Why, the What and the How of communication-centered architectures. Attendee Background: The intended audience is senior programmers, information architects and managers who are interested in information systems architecture and development strategy. Participants should know OO programming and understand basic WWW concepts. The examples will be taken from the world of Java, but we do not assume prior knowledge of the Java language, components or distribution technologies. Trygve Reenskaug has 35 years experience in developing industrial strength software products combined with software engineering research. His firsts include structured programming and data base oriented architectures in the early sixties; object oriented applications and personal computer systems in the early seventies; experimental Model-View-Controller, the world's first reusable object-oriented framework, in 1979; and the premier book on role modeling in 1995. He is currently developing a method for the practical application of distribution technology. Lasse Bjerde is R&D Manager at Numerica Taskon. He has 15 years experience in the object-oriented paradigm. He has teaching experience from several courses in the OOram method, UML and general OO. He has been part of the development team behind the OOram Method and Tools since the beginning of the nineties. He is currently heading several international projects dealing with distributed development. |
| 72 | Refactoring: Improving the Design of Existing Code Martin Fowler, Independent Consultant |
Colorado Convention Center - A106 |
| Almost every expert in Object-Oriented Development stresses 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 function 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. Attendee Background: All the examples will use Java so you should have a working knowledge of Java. Martin Fowler has spent over a decade to applying object technology to business information systems. He is an independent consultant who trains and mentors his clients in OO analysis, design and programming, patterns, and refactoring. He is the author of "UML Distilled" and "Analysis Patterns". His latest book,"Refactoring", is due to appear in mid 1999. |
Thursday Afternoon/Half Day
| 73 | Java Beans Specification, Design, and Test Desmond D'Souza, Platinum Technology |
Colorado Convention Center - A103 |
| Java Beans promise standard re-usable parts that can be easily composed. To be replaceable and scalable beyond UI parts, the behavior of a Bean should be described in a way which is abstract (permit many implementations) and precise (clear, unambiguous, a basis for qualification and test). This tutorial will describe an approach to the precise and systematic specification of a Java Bean, extended to its design, implementation, and test, based on the Catalysis approach to design and build components using UML.
Participants will learn (a) key differences between objects and components, (b) how to specify interfaces precisely, (c) how to model properties, methods, events, (d) the basis for testing Java Beans based on their specifications, (e) a systematic approach to modeling and designing with components. Attendee Background: Attendees must be familiar with Java and Java Beans basics, and with UML and basic object modeling. Desmond D'Souza is VP of component-based development at Platinum Technology, co-author and developer of the Catalysis method for systematic development of business-driven component systems, published by Addison Wesley. A frequently invited speaker to companies and conferences, and writes the Modeling for Java column in the Journal of Object-Oriented Programming. He may be contacted at dsouzad@acm.org . |
| 74 | Squeak as a Development Platform Tansel Ersavas, RaSE Inc. |
Colorado Convention Center - A101 |
| Squeak is a new implementation of Smalltalk-80 with a Virtual Machine written in Smalltalk. Squeak is quickly becoming a viable platform for developing systems as well as for teaching object-oriented programming. This tutorial will highlight the key features of Squeak such as the Morphic User Interface, Balloon resolution independent graphic system, networking abilities, Internet usage, and the integration of Squeak to object databases such as Gemstone. Examples will be provided.
Participants will familiarize themselves with Squeak and its environment and will feel comfortable in Squeak environment. They will be introduced to all highlights of Squeak such as Morphic, Balloon and Networking. They will observe advantages of using Squeak and learn what types of systems are good candidates for using Squeak Attendee Background: Participants should have a general familiarity with the object-oriented paradigm. Familiarity with Smalltalk will be useful, but not required. Tansel Ersavas is the President of RASE Inc. He holds a B.S. and an M.S. in computing and has worked in the field since 1979. He is a the designer and developer of the Snowball Rapid Systems Engineering Tool and the Fuzzy Object and Behavior Modeling technique. |
| 75 | Using UML in the Design of Software Architectures Derek Coleman, Hewlett-Packard |
Colorado Convention Center - A108 |
| The architecture of a system is an explicit high-level model which defines the structure and the behavior of a system. Software architectures afford flexibility in design and are therefore the key to the successful development of product families. Software architectures also form a shared model between stakeholders in the system. The essential value of an architecture is that a wide-variety of thought experiments about a system can be conducted by evaluating the impact of what-if scenarios on the architecture.
UML is the OMG standard for object-oriented modeling throughout the software lifecycle. UML is emerging as the de facto standard for the visual modeling of software. The objectives include:
The tutorial is based on the practical experience of using UML to design and document architectures in Hewlett-Packard and other companies. Attendee Background: The tutorial is aimed at software engineers, project managers and software process engineers interested in UML and software architectures. Preferably participants should have some knowledge of object-oriented concepts and software engineering. Derek Coleman leads the architectural consultancy group in Hewlett-Packards Product Generation Services. 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. |
| 76 | Using Metadata and Active Object-Models to Implement Fowler's Analysis Patterns Joseph W. Yoder, The Refactory, Inc. Federico Balaguer, The University Of Illinois |
Colorado Convention Center - A113 |
| Fowler presents some Analysis Patterns that describe a dynamic model that can adapt smoothly to new requirements without necessarily needing the programmer to change the way that objects interact. Analysis Patterns are quite different than Design Patterns in that they describe recurrent problems in term of the elements or concepts that are present in a problem domain. Analysis Patterns will influence how the code is designed but does not directly deal with implementation details as is done is Design Patterns. To implement such dynamic systems, you are building an active object-model. Therefore, this tutorial will explain Active Object-Models and how to implement them. A system with an Active Object-Model has an explicit object model that it interprets at run-time. If you change the object model, the system changes its behavior. This tutorial describes how we extended and implemented Analysis Patterns in the medical domain. This work is based upon the results of our experience implementing the observation model for the Illinois Department of Public Health.
Attendee Background: Attendees should have an understanding of the GOF patterns and Fowler's Analysis Patterns. The intended audience is for those that are working on developing frameworks or visual languages or very dynamic systems. Joseph W. Yoder has been studying and developing software since 1985. Since 1990 his focus has been on object-oriented technology. For the last few years Joe has been investigating "visual languages for business modeling" and "active object-models". 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. Federico Balaguer has been developing object-oriented software for over ten years. He is currently working on implementing Martin Fowler's Analysis Patterns at Illinois Department of Public Health and is also working with Professor Ralph Johnson on finishing his Ph.D. |
| 77 | An Introduction to Smalltalk for Developers and Managers Kenneth Perry, Consultants, Salient Corporation James DuWaldt, Consultants, Salient Corporation |
Colorado Convention Center - A107 |
| After year 2000 developers and managers will find waiting for them (1) a raft of held-up requests and (2) management driven by competition to both accelerate development schedules and shrink their Y2K crisis-bloated IT budgets.
The Smalltalk language and environment meets the need for rapid and productive development with error rates one-half of other languages (according to studies of large systems by the Software Productivity Research Institute) because it is untyped, automatically handles memory allocation, and has a mature class library. Platforms supported by various language vendors include Win98/NT, Macs, MVS, LINUX, and others. We will introduce attendees to standard class hierarchies such as Collections and Streams, individual classes like Processes, Semaphores, and Gatekeepers, and environmental tools like the Debugger, Inspectors, and the Refactoring Browser in the context of a Distributed System with COM Automation. References to commercial and non-commercial products, a reading list, and the samples in the tutorial will be made available. The objective of this tutorial is to jump-start an understanding of Smalltalk and its ability to solve attendees real-world problems. Attendee Background: Assumes knowledge of and experience with Object Oriented concepts. Kenneth (Ken) Perry wrote his first program in 1964 and developed his first commercial business application in 1965 and has been consulting in the development of primary support systems for large corporations for the last 20 years. James (Jim) DuWaldt has worked on a wide range of systems, from trunk diagnostic software on central telephone switching office processors at Bell Laboratories to real time analysis displays with the first generation of Zoran DSP chips to accounting and banking software on PCs. Jim has been using the IBM and ObjectShare desktop flavors of Smalltalk since 1992 and enjoys their flexible environment and informative debugging tools. |
| Typical object-oriented development techniques assume target systems have relatively large amounts of RAM available to the user. Developers working with tight memory requirements also need the flexibility and encapsulation which OO can provide, but cannot afford to produce systems with large memory requirements. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using an approach based on design patterns and practical examples, this tutorial will explore some of the most important techniques that successful designers use in object oriented systems for small memory machines.
This tutorial will help participants manage object oriented development in limited-memory environments. The tutorial will present specialized design patterns, including patterns for preparing and managing memory budgets, designing and allocating object structures, transparently exploiting auxiliary storage, and tailoring user interfaces for small machines. The patterns will be illustrated with case studies to provide experience for the participants in designing their own solutions. Attendee Background: We expect this tutorial will be useful to software developers with a year's experience using an O-O programming language, technically experienced team leaders managing teams working on memory-limited systems, and experience of working with memory-limited systems will be helpful but not essential. Charles Weir has more than fifteen years' experience with software development and object-oriented techniques. Charles was software architect for the Web Browser development for the Psion Series 5 palmtop computer. Charles has taught many courses on Object-Oriented design and Implementation, has led several active-learning sessions at the UK Object Technology series of conferences. Dr. James Noble is a Research Fellow at the Microsoft Research Institute at Macquarie University, Sydney. He established the Sydney Patterns Group, the first patterns group in the Southern Hemisphere. James and Charles are collaborating on a book "Patterns for Small Machines" that describes patterns for memory-constrained systems, to be published by Addison-Wesley in 1999. |
| 79 | `Real' Thin Client Alternatives for Object-Oriented Applications Skyler Thomas, IBM VisualAge Solutions Group |
Colorado Convention Center - A104 |
| As Object Oriented projects mature, more and more emphasis is placed upon building distributed systems. Currently, there exist a myriad of methods to accomplish this objective. This tutorial will examine a number of these alternatives and discuss the relative merits of each solution. Special attention will be given to scalability, ease-of-development, and business case. Topics will include: CORBA, COM/DCOM, EJB's, RMI, Object Databases, and Component Broker.
This tutorial is intended to prepare the participant
Attendee Background: The tutorial is targeted at those individuals interested in thin-client object solutions. It is assumed that the audience has some familiarity with the basic concepts of object technology and has already begun to deploy the technology in their organization. Skyler Thomas is a Senior Consultant with the IBM VisualAge Solutions Group and has been working with object technology for over seven years. Skyler has worked internationally with numerous corporations in the Banking, Insurance, Government, and Retail sectors and has authored several articles and technical reports. |
| 80 | Semantic Analysis Patterns Eduardo B. Fernandez, Florida Atlantic University |
Colorado Convention Center - A106 |
| The analysis stage is a crucial stage of object-oriented software development. Semantic analysis patterns have been proposed as a way to make this stage easier and more accurate. They can also be the basis of system components or entire frameworks. An analysis pattern is a set of classes and associations that describe a recurring conceptual structure; for example, inventory, billing, shipping. We discuss in detail some specific patterns and show how to develop patterns by analogy and abstraction. UML is used to describe the examples. Compared to Fowler's patterns, our patterns are intended to describe a significant portion of the semantics of an application, as opposed to improving the flexibility of the model.
Dr. Fernandez is a professor in the Department of Computer Science and Engineering of Florida Atlantic University, Boca Raton, FL. He has an MSEE degree from Purdue University and a Ph.D. in Computer Science from UCLA . He has written three books and is an active industry consultant and instructor. Recently, he developed an object-oriented inventory control system prototype for Motorola. |
|
The increased complexity associated with large-scale systems requires an increase in the sophistication of the methodology used to manage their development. OPEN (Object-oriented Process, Environment and Notation) is a third generation methodology that focuses not only on model building but also on project management, quality, reuse, and full and customizable lifecycle support. The customizable nature of OPEN will be the focus of this tutorial. The Activities and Tasks that make up an OPEN lifecycle (software engineering process) will be described, emphasizing the pre- and post-conditions that are used to manage the customized lifecycle. During the tutorial participants will be given the opportunity to develop an initial high-level OPEN lifecycle for their own organizations.
Upon completing this tutorial participants will understand the benefits to be gained by developing a software engineering process that is customized for their organization. Participants will understand the contract-driven lifecycle of OPEN and how it is used to develop a customized software engineering process. Participants will know where they can go to find further information to help them in their application of OPEN. Attendee Background: Participants need to be familiar with object oriented software development and the need for a full lifecycle process methodology. Richard Thomas is a lecturer in software engineering in the School of Computing Science at the Queensland University of Technology (QUT). His current research interest is in developing a process to guide organizations adopting object technology. He is a member of the Centre for Object Technology Application and Research (COTAR), the premier object technology research center in Australia. Richard is also a director of Thomaco Consultancies, a technology consultancy that specializes in software engineering and object technology. He has practiced object technology for over a decade as a designer, implementer, researcher, lecturer and consultant. |
|
at a Glance |
|
of all Tutorials |
Final Program |
