(45) Introduction to Distributed Object Computing
Waverly Hotel, Galleria
Eric Jul, University of Copenhagen
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 introductory tutorial is to teach the basic ideas and paradigms of distributed object computing rather than a specific technology.
Issues covered include: communication, RPC; remote referencing, proxies; separation of concerns: interface and implementation; parallel processes; distributed, globally shared objects; distributed synchronization; reliability/failure handling; replicated objects; persistent objects; short overview of major implementation issues; short overview of available distributed object systems and languages; JAVA distribution issues; and CORBA distribution issues.
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 but not essential.
Eric Jul is an Associate Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he heads the DistLab group which is doing research in distributed, heterogeneous computing. He is a co-designer and principal implementor of the Emerald distributed object-oriented programming language developed at the University of Washington. His interests include distributed, OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPSLA conferences he has run a number of workshops and tutorials related to distributed computing.
Other distributed computing tutorials are:
(46) Software Reuse: Architecture, Process
and Organization for Business Success
Cobb Galleria Centre, Williams Ballroom, Section B
Martin Griss, Hewlett-Packard Laboratories and Ivar Jacobson, Rational Software Corporation
Object technology (OT) is believed to be crucial to achieving the long sought-after goal of widespread reuse. This goal is the most frequently stated reason for adopting OT. Unfortunately, many people naively equate reuse with objects, expecting it to "automatically" ensure reuse, but often do not get much reuse.
Based on our experience with reuse at HP, Objectory and Rational, and with our many customers, we know that without extensive changes to support component-based development and systematic reuse, OT as used today will not succeed in giving users reuse. Without an explicit reuse agenda, and a systematic approach to the design and use of reusable components and frameworks, OO reuse will not succeed. In almost all cases of successful reuse, architecture, a dedicated component development and support group, management support, and a stable domain were the keys to success. These largely non-technical issues seem to be more important to successful reuse than the specific language or design chosen.
In this tutorial we address this architecture/process/organization question systematically. We describe an exciting and coherent approach which applies Object-Oriented Business Engineering concepts of BPR to restructure a software development organization to offer reuse at a large scale. This is outlined as a generic and customizable "Reuse Business" framework. Since the transition to a Reuse Business is a complex and risky endeavor, it is important to do it systematically. Our approach therefore combines the techniques of BPR, change management and incremental reuse adoption.
To obtain a true systematic OO reuse process, we have augmented the Use Case Driven Object-Oriented Software Engineering (OOSE) with specific reuse-oriented architectures and processes, coupled with organization and infrastructure guidelines and training. We have based our work on the new Unified Modeling Language (UML 1.0), taking full advantage of the features for packages, stereotypes, facades, patterns, etc.
We have extended the OOSE process to start from a business model of the target organization, with specific architecture and component design steps. Component and framework engineering includes explicit design and implementation guidelines, building on a catalog of architectures, patterns, designs and mechanisms. We provide a structured approach to produce layered, modular architectures.
Background: Intended participants are experienced OO practitioners and software managers.
Ivar Jacobson is inventor of the OOSE method, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation and previously VP of Technology at Objectory Corporation. He is a leader in the OO community. He is well known for his pioneering work and more than 20 years experience using object methods for the design of large real-time systems. He spent 25 years at Ericsson working on the AXE switching system, where he developed an architecture and software engineering process to support extensive reuse. His early object-based design technique has evolved into the international CCITT/SDL Telecom standard. He is the principal author of two influential books, "Object-Oriented Software Engineering -- a Use Case Driven Approach" and "Business Process Reengineering with Object Technology," as well as several widely referenced papers on object technology. His work on Use-case engineering has influence almost all of the OO methods in use today. He has served on the OOPSLA, ECOOP and TOOLS program committees.
Martin L. Griss is a senior Laboratory Scientist at Hewlett-Packard Laboratories, Palo Alto, California where for the last 14 years he has researched software engineering processes and systems, systematic software reuse, object-oriented reuse, and measurement system kits. He has a defining role as senior reuse consultant within HP's Professional Services Organization. As HP's "reuse rabbi", he led research on software reuse process, tools, and software factories; the creation of an HP Corporate Reuse program; and the systematic introduction of software reuse into HP's divisions. He was director of the Software Technology Laboratory at Hewlett-Packard Laboratories, and has over 25 years of experience in software engineering research. He was previously an associate professor of computer science at the University of Utah, where he is currently an adjunct professor. He has authored numerous papers and reports on software engineering and reuse, writes a reuse column for Object Magazine, and is active on several reuse program committees.
Other related tutorials are:
(47) The (upcoming) Standard C++ Library
Cobb Galleria Centre, Williams Ballroom, Section C
Jan Christiaan van Winkel and Marian Hellema, AT Computing
The C++ language lacked a standard library so far. Of course the iostream library has been there from the beginning, but a more fully equipped library has now been introduced in the ANSI/ISO draft C++ standard. Some of the features of this new library (such as string classes and complex number classes) have been implemented by many programmers, but they are standardized now. Moreover, the new Standard Template Library (which is a part of the standard C++ library) will change the way programs in C++ are written. The Standard Template Library contains templates for algorithms, container classes, iterators, function objects and adaptors. STL is a major part of the tutorial. This tutorial will give an overview of the standard C++ library so you will know what to expect when it is available for your favorite C++ compiler. It will be based on the latest available public draft C++ standard.
Background: The attendees are expected to know C++. This tutorial will only discuss the "extras" of the standard.
JC van Winkel has a B.Sc. and a M.Sc. in computer science (the M.Sc. from the Vrije Universiteit Amsterdam). After working as a programmer/consultant for KPMG EDP Auditors for 6 years, he started at AT Computing in 1990. There he teaches UNIX and UNIX-related subjects, including C and C++. He co-authored the course notes for the C++ course with Marian Hellema. These course notes will be published as a book by the Dutch publisher "Academic Service". JC van Winkel presented tutorials at OOPSLA '93, OOPSLA '94 and OOPSLA '96.
Marian Hellema develops and gives courses in C, C++, Java and UNIX. After working at the Academic Computer Center, Amsterdam, she now works as a trainer for AT Computing, Nijmegen, the Netherlands. She received a master of science degree in social sciences from the University of Utrecht, the Netherlands. One of the subjects she studied was Information Sciences. After that, she was trained as a software system designer. She co-authored the course notes for the C++ course with Jan Christiaan van Winkel. These course notes will be published as a book by the Dutch publisher "Academic Service". Marian Hellema presented a tutorial at OOPSLA '96.
Those interested in moving from C++ to Java can attend:
(48) Object-Oriented Heuristics and Their
Relationship to Design Patterns
Cobb Galleria Centre, Williams Ballroom, Section E
Arthur J. Riel, Vanguard Training Inc.
A common complaint of the object-oriented novice is the lack of knowledge concerning the "goodness" of an object-oriented design. Upon seeking help from an expert, the novice is frustrated to learn that an object-oriented design is good when it "feels right". While vague, there is some truth to the "feel right" suggestion. The expert has built up a collection of subconscious heuristics which he or she runs over the design. If these heuristics are satisfied then the expert "feels right" about that design. This tutorial attempts to translate that subconscious list of heuristics into a very conscious list of complexity and productivity heuristics. Towards this goal each attendee will receive a list of more than sixty object-oriented design heuristics collected and/or developed by the author. These heuristics can be used to detect potential design flaws before they are integrated into an application.
The motivation and use of these heuristics will be demonstrated through several examples including the use of heuristics to avoid the two main problems in object-oriented design (i.e., the "god" class problem and the "proliferation of classes" problem). The attendees will see how six heuristics guide the designer in the avoidance of the first problem, while ten additional heuristics are responsible for the avoidance of the second. In addition, the lecture will illustrate the relationships between design heuristics and design patterns. In short, design heuristics inform the object- oriented developer that he or she has a problem, while design patterns provide the solution to the design flaw. In this way design heuristics can help fill two gaps in the research of object-oriented design patterns: (1) How does a designer know when a particular pattern should be applied? (2) How can a designer "glue" design patterns together to create more interesting and larger grained patterns?
Background: Some knowledge of Object-oriented programming.
Arthur J. Riel has over thirteen years experience in OOA/D and C++. He has participated in the development of many large systems including two real-time process control systems (Bell Laboratories, Draper Laboratories), a microcode assembler (IBM), the Demeter system (an object-oriented CASE developed at Northeastern University), and a commercial library of reusable C++ components called Classix (Vanguard Software Incorporated). Arthur is the author of a text book titled "Object-Oriented Design Heuristics" available from Addison-Wesley (5/96). His current pursuits include the development of good heuristics for object-oriented analysis/design/C++, the development and reuse of object-oriented frameworks, and the development of object-oriented design patterns and their associated pattern languages. In addition, Arthur teaches more than forty courses (OOA/D, C++) per year in both corporate and academic environments. He can be reached at 72360.151@compuserve.com.
The following could be taken in preparation for this tutorial:
(49) The Manager's Role in a Successful Transition
to Object-Orientation
Cobb Galleria Centre, Room 102
Norm Kerth, Elite Systems
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 his/her organization to new effectiveness of this technology. The pressure to participate in the Internet, as soon as possible, only adds to the importance of the manager's role.
This highly acclaimed tutorial discusses what managers should expect and need to do as their organizations grow in their maturity to use objects. It is a tutorial loaded with a great deal of wisdom and experience.
To realize these benefits and avoid the pit falls it is not good enough to simply let a few engineers use an object-oriented language. There is a great deal that needs to be managed, controlled and nurtured. In this tutorial, you learn how to develop a program that allows you to manage the introduction of this new technology into your projects.
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.
Background: There are no prerequisites for this tutorial.
Norm Kerth is a consultant working with companies interested in ensuring that they make a successful transition to using the object-oriented technologies.
Before starting his consulting company, Elite Systems, Norm held the position of Principal Engineer/Research Professor in the University of Portland's Applied Research Center. He is an expert in the areas of specification and design methodologies and CASE tools. He has special interests in the areas of specification for human interface intensive problems and bringing engineering discipline to the practice of developing object-oriented programs. He also has a decade of engineering experience with Tektronix and has been a frequent participant at OOPSLA since 1987.
Other management tutorials are:
(50) Applying UML
Cobb Galleria Centre, Room 103
Craig Larman, ObjectSpace, Inc.
The Unified Modeling Language (UML) represents an emerging standard notation and set of semantics for object-oriented analysis and design (OOA&D) artifacts. This tutorial provides an intensive learning environment in which to practice applying the UML by creating various OOA&D deliverables, such as conceptual models. Based on adult learning principles, this is a lively hands-on session in which participants work in small groups to create artifacts: use cases, conceptual models, collaboration diagrams, and so on. A cohesive understanding of a process for OOA&D in conjunction with the UML notation is achieved by its application to a realistic information system problem. While creating collaboration diagrams, participants will strengthen their design skills by learning and applying the GRASP patterns for general assignment of responsibilities. Consistency and feedback are achieved by interleaving group work with lecture and solutions presented by the tutorial leader.
Background: Participants should have introductory-level familiarity with an object-oriented analysis and design method, such as OMT. In particular, participants should have experience creating at least one conceptual (object) model and message diagram in some method. The intended audience is software developers of object-oriented systems who wish to transition to and apply the Unified Modeling Language during object-oriented analysis and design.
Craig Larman has been using object technology since 1984 when he started developing knowledge systems on LISP machines. He is very active in teaching and mentoring developers in the use of the UML, having presented the OOPSLA '96 and Smalltalk Solutions '97 UML tutorials, and taught over four hundred participants in five-day courses throughout the United States and Canada. In addition, he is near completion on a book introducing object-oriented analysis and design using UML "Applying UML and Patterns" (Prentice-Hall, 1997). From the mid 1980's to 1990's he played the dual role of college instructor and software developer, developing object-oriented and non-object-oriented applications, and assisting others in learning object-oriented analysis and design, Smalltalk and C++. To date, he has personally taught object technology skills to approximately two thousand students. Currently, he works as Principal Object Technology Instructor with ObjectSpace, Inc. Craig holds a B.Sc. and M.Sc. in computing science.
Other related tutorials are:
(51) Pattern-Oriented Software Architecture
Cobb Galleria Centre, Room 104
Hans Rohnert, Siemens AG
A pattern gives a solution schema to a recurring design problem in software development. While patterns have been gaining considerable attention during the last few years, previous efforts concentrated on low-level patterns (idioms) and mid-level patterns (design patterns).
This course will discuss patterns at several levels of abstraction. It will present a system of patterns for software architecture that combines high-level patterns with an enriched set of lower-level patterns, and organizes them into a cross-referenced catalog.
The course starts out with an in-depth explanation of the notion of patterns, presenting example patterns at different levels of abstraction. Then we give an overview of existing work and a narrative exposition of the pattern community.
Most of the time will be spent on describing specific patterns on different levels. Example patterns are: Layers, Pipes and Filters, Presentation-Abstraction-Control Model-View-Controller, Publisher-Subscriber, Client-Dispatcher-Server, Mediator, Decorator, Visitor, and Counted Pointer. We will conclude with an assessment of today's appreciation of patterns as well as some speculation on the future.
Background: Fundamentals of Object Technology. Solid general programming knowledge.
Dr. Hans Rohnert has been with the Siemens Corporate R&D labs in Munich, Germany for the past eight years. His job is to do research as well as being an in-house consultant to other Siemens companies. He participated in many object-oriented design sessions and development projects. He used to program in C/C++ and switched to Java programming two years ago. His current assignments are researching and teaching Java and patterns as well as developing server end software for WWW clients.
Hans got his education at the University of Saarland and the International Computer Science Institute at UC Berkeley. His professional interests include patterns, object-oriented programming, and combinatorial algorithms. He is a co-author of "Pattern-Oriented Software Architecture", (John Wiley & Sons, 1996).
The following are good introduction:
(52) Building Frameworks in Java with Patterns
and Interfaces
Cobb Galleria Centre, Williams Ballroom, Section D
Ken Auer, RoleModel Software
This tutorial teaches attendees the important issues in building robust frameworks in Java. We will identify the essential characteristics of such frameworks and show how patterns and interfaces provide significant leverage to realize these characteristics. A running example of a Direct-Manipulation Graphical framework will be used to demonstrate concrete examples of the appropriate use of the abstract concepts to produce a whole which is greater than the sum of its parts. Along the way, we will discuss: (1) How to avoid the dangers of over-designing with patterns and over-factoring with interfaces; (2) The fine balance between top-down design and bottom-up discovery; and (3) Issues specific to the language features of Java and the class libraries in the JDK which make framework building easier or more difficult.
Background: Participants should be literate in Java, exposed to Patterns, and should have at least one year of first-hand experience applying object technology.
Ken Auer has been working with object technology since 1985. Since that time, Mr. Auer has been the chief architect for a number of successful frameworks and systems ranging from small prototypes, to large distributed, multiple language systems with team sizes ranging from 1 to 150. He has particular expertise in creating efficient, high-quality, reusable components, frameworks, and architectures. Many of his creations are actively being used in industry today. Mr. Auer is well-known for his expertise in object technology through many published articles and book contributions and frequent invitations to participate in industry conferences, panels, and workshops. He founded RoleModel Software in 1997, after almost 9 years as a consultant with Knowledge Systems Corporation. He also serves on the editorial board of "Object Magazine" and is a member of The Hillside Group.
Other Java and Framework tutorials are:
(53) Understanding Smalltalk Graphics
Cobb Galleria Centre, Room 105
Bobby Woolf and Kyle Brown, Knowledge Systems Corp.
One of Smalltalk's most powerful features is the flexibility it provides in implementing customized graphical user interfaces (GUIs). When used for this purpose, Smalltalk is more powerful and flexible than 4GL-based products like PowerBuilder, and is easier to use than other OO languages such as C++ and Java.
Each major Smalltalk dialect has a window painter kit, either built into the product or available as an add-on product. These window painters provide many visual components ready for reuse. However, organizations often discover the need for visual presentations that cannot be created using the standard widgets. Complex bubble-and-arrow graphs, charts, 3-D graphics, and so forth are beyond the capabilities of the available visual components. A programmer must implement his or her own customized visual components to display information in these ways.
This tutorial has two parts: an overview of graphics in Smalltalk and a detailed look at how graphics work in VisualWorks. The tutorial notes will also cover Visual Smalltalk and IBM Smalltalk in detail. This tutorial will show you what you need to know to move beyond the window painters and implement your own custom graphical views in Smalltalk. As a running example, we'll show how to implement a simple Calendar View. We'll reference many of the patterns in the Design Patterns book by Gamma, et. al.
Background: Participants should be experienced Smalltalk programmers and should know how to use a window painter such as the VisualWorks Painter or Window Builder Pro.
Kyle Brown is a Senior Member of Technical Staff at Knowledge Systems Corp. in Cary, NC. He has been developing custom graphics in Smalltalk for over seven years. He has developed custom graphical interfaces for applications in Engineering, MIS and scientific computing.
Bobby Woolf is a Senior Member of Technical Staff at Knowledge Systems Corp. in Cary, NC. He has published articles in "The Smalltalk Report" chronicling the evolution of the model-view-controller framework in ParcPlace Smalltalk and its implications for all Smalltalk dialects.
Kyle and Bobby have presented this tutorial at OOPSLA '95 and '96, Smalltalk Solutions '95 and '96, and Object Expo Europe '95. Kyle and Bobby have implemented custom graphics in all three Smalltalk dialects. They have extensive teaching, mentoring, and presentation experience as part of their consulting jobs at KSC. Kyle and/or Bobby have presented at Smalltalk Solutions, OOPSLA, Object Expo Europe, ParcPlace-Digitalk Users Conference, Software Development East, and PLoP. They have published in "The Smalltalk Report", "Object Magazine", and the PLoP books.
Other Smalltalk tutorials are:
(54) The OPEN Method and Modeling Language:
A Complete Example
Cobb Galleria Centre, Rooms 113-114
Donald G. Firesmith, Storage Technology Corporation
This tutorial has three main goals: (1) to introduce the attendee to the OPEN Method, its modeling language, and especially its notation; (2) to explain their advantages over OMT and UML; and (3) to present and explain representative examples of COMN models taken from a complete requirements specification and design document that was developed in accordance with an OPEN-complaint content and format standard for OO documentation.
Background: Attendees should be familiar with at least one OO development method. Exposure to OMT or UML would be useful, but is not required.
Donald Firesmith has worked exclusively with objects since 1984, concentrating in the areas of OO project management, development methods, and testing. He spoke at the first OOPSLA, has been a member of the OOPSLA and TOOLS program committees, and given presentations and tutorials at numerous conferences including ObjectEXPO, Smalltalk Solutions, TOOLS, etc. He has authored or co-authored four books on object technology, has published numerous articles, and has developed a pattern language for testing OO software. He is the principal co-author of the "OPEN Modeling Language (OML) Reference Manual" and "Object-Oriented Development using OPEN: A Complete Application".
Other specific methods tutorials are:
(55) Object-Based Concurrent And Distributed
Computing - Survey and Classification
Cobb Galleria Centre, Rooms 115-116
Jean-Pierre Briot, Universite Paris 6 - CNRS and Rachid Guerraoui, Ecole Polytechnique Federale de Lausanne
This tutorial aims at providing a comprehensive survey of the technology of object-based parallel and distributed computing. Therefore, it discusses and classifies the various ways the object paradigm is used in both parallel and distributed contexts. More precisely, they are grouped into three main approaches: "applicative", "integrative" and "reflective".
Roughly speaking, the Applicative approach helps the system designer to structure parallel and distributed computer systems through a set of generic libraries. The Integrative approach provides the application programmer with a simple unified model by merging concepts such as: object and activity, message passing and transaction. The Reflective approach may be considered as a bridge between the two previous approaches as it helps at integrating protocol libraries intimately within a programming language or system, thus helping at its dynamic customization. During the tutorial, each approach is analyzed, compared, and illustrated by several examples of existing languages or systems.
Background: This tutorial is organized for those who are familiar with object-based programming in general and wish to comprehend the issues and directions in object-based parallel and distributed computing. No specific experience in concurrent or distributed programming is needed. Although the concerns of parallel computing and distributed computing are partly different, this tutorial is unique in that it provides a global analysis of both aspects and covers a wide range of research and development in object-based parallel and distributed languages and systems.
Jean-Pierre Briot is a CNRS researcher at LAFORIA, Institut Blaise Pascal, Paris, France. He took part in the design of several object- based concurrent programming projects, including an Esprit parallel computing action that he co-headed. He recently co-edited a book on "Object-Based Parallel and Distributed Computation".
Rachid Guerraoui holds a position as a lecturer at the Operating System Lab of the Computer Science Department in Ecole Polytechnique Federale de Lausanne (EPFL). He is technical coordinator of the "OpenDreams" Esprit project which aims at designing a CORBA compliant platform for industrial applications. He teaches Object-Oriented programming at EPFL and has co-edited a book on "Object-Based Distributed Programming".
Mr. Briot and Mr. Guerraoui have been members of the program committee of several OOPSLAs and ECOOPs.
Other distributed computing tutorials are:
(56) Efficient Implementation of Object-Oriented
Programming Languages
Cobb Galleria Centre, Rooms 117-118
Craig Chambers, University of Washington
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? In this tutorial I aim to answer these questions. I will begin by identifying the main features of object-oriented languages that are difficult to implement efficiently. The remainder of the tutorial will present three classes of implementation techniques. First, I will describe run-time system techniques such as virtual function dispatch tables (including complications due to multiple inheritance and virtual inheritance) and inline caches. Second, I will describe static intra- and interprocedural analyses 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, I will discuss ways in which dynamic execution profiles can be exploited to complement static analysis techniques. I will present empirical measurements of the effectiveness of many of these techniques, as implemented in the Vortex optimizing compiler, for large benchmarks written in C++, Java, Modula-3, and Cecil.
Background: Attendees should be familiar with the features of object-oriented languages and also with traditional compiler techniques like procedure inlining and data flow analysis.
Craig Chambers has been researching object-oriented language design and implementation since 1987, with publications in OOPSLA, ECOOP, ISOTAS, PLDI, PEPM, and TOPLAS publications on the topic. He developed the first efficient implementation of the Self language, and he is the designer of the Cecil language and heads the Vortex optimizing compiler project. Chambers is currently an Assistant Professor of Computer Science & Engineering at the University of Washington.
Other advanced tutorials are:
[ OOPSLA '97 Home Page | SIGPLAN | ACM ]