Register early -- OOPSLA Tutorials sell out quickly!
Sunday Full Day
SPEAKER(S)/AFFILIATION: Raimund K. Ege, Florida International University
ABSTRACT: This tutorial defines and teaches the basic object-oriented concepts illus- trates 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 C++ as its sample language to illustrate the material. Part 2 compares major object-oriented programming languages: C++, Smalltalk, Eiffel, Java, and others. The comparison is done with a double focus: (1) how does the language support and enforce the concepts, and (2) how does the language help software development (to that effect, I have a small case study program, that will be solved in all languages).
BACKGROUND: No previous knowledge of object-oriented concepts is assumed. The attendees should have a fundamental background in computer science and knowl- edge of a modern programming language, such as C, Pascal or Ada.
BIOGRAPHY:
Raimund K. Ege is an Associate Professor of Computer Science at the Florida International University, Miami. He is author of Programming in an Object- Oriented Environment (Academic Press, 1992) and Object-Oriented Program- ming 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.
RELATED TUTORIALS: Tutorials 32 Pattern-Oriented Software Architecture , 35 OLE, CORBA - Infrastructures for Distributed Object Computing, 39 Introduction to CORBA, and 45 A Survey of Object-Oriented Analysis and Design Methods are other introductory tutorials.
Back to OOPSLA '96 Tutorial Overview
Sunday Full Day Tuesday Full Day
SPEAKER(S)/AFFILIATION: Dr Mary E.S. Loomis, Hewlett-Packard Laboratories Akmal B. Chaudhri, City University, London
ABSTRACT: This tutorial will be divided into two parts. In the first part, participants will be introduced to the various alternative approaches to providing persistent storage for objects, the architectures of the object database systems, and the kinds of DBMS functionality provided for object systems. Emphasis will be placed on transaction management and on query processing. This first part of the tutorial will also include a section on the coexistence of objects and relational databases.
The second part will look at benchmarks and performance. In object database literature, these are often cited as factors that are among the most important to users when considering which object database product to purchase. Delegates will be introduced to some of the popular object database benchmarks (e.g. OO1, OO7, JUSTITIA), how to design and develop their own benchmarks and issues (e.g. tuning) that can affect performance.
BACKGROUND: Participants should have good familiarity with the object-oriented paradigm or a good understanding of how to use database systems. They may come from a strong OO language background or be familiar with traditional (relational) database technology and wish to learn about object databases and object data management.
BIOGRAPHY: Mary Loomis has been involved in various aspects of object databases since 1975, with experience in a broad range of pertinent topics, including semantic databases, network databases, relational databases, object databases, data modeling, and object modeling. Originator of the OMT modeling technique. Vice-President of Technology for Versant Object Technology, a primary purveyor of object DBMS products. Founding member of the ODMG (Object Database Management Group standards team) and currently chair of the OMG's Analysis and Design Task Force. Currently manager of the software research organization at Hewlett-Packard Laboratories.
Akmal B. Chaudhri has been involved in teaching and research in object databases since 1991. At present, working on object database benchmarks by case studies.
RELATED TUTORIALS: Tutorials 32 Pattern-Oriented Software Architecture, 35 OLE, CORBA - Infrastructures for Distributed Object Computing, 39 Introduction to CORBA, and 45 A Survey of Object-Oriented Analysis and Design Methods, are other introductory tutorials.
This tutorial will be repeated on Tuesday.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM Wednesday PM
SPEAKER(S)/AFFILIATION: John Vlissides, IBM Research
ABSTRACT: 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.
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 assumed or required.
BIOGRAPHY: 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. He writes the "Pattern Hatching" column for the _C++ Report_. John has a Ph.D in Electrical Engineering from Stanford University.
The presenter is co-author, along with Erich Gamma, Richard Helm, and Ralph Johnson, of _Design Patterns: Elements of Reusable Object-Oriented Software_.
RELATED TUTORIALS: Tutorials 29 Design Patterns Applied, 19 Application of Design Patterns in Commercial Domains, and 50 Object Oriented Design Patterns for Concurrent, Parallel, and Distributed Systems,also discuss design patterns.
This tutorial will be repeated on Wednesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM Tuesday PM
SPEAKER(S)/AFFILIATION: Ivar Jacobson, Rational Software Corporation
ABSTRACT: This tutorial presents a generalization of the use case driven approach. Use Case Engineering (UCE) is a fundamental approach to engineering systems that fits the needs of their users. In UCE, Use Cases can be used in combination with a variety of object and non-object modeling techniques. Over the years, UCE has been used in a wide range of different disciplines such as: business engineering, software engineering, hardware engineering, mixed SW-HW systems and computer CPUs.
BACKGROUND: Attendees should have some experience using OO analysis and design methods. Experience using Objectory is useful but not required.
BIOGRAPHY: Ivar Jacobson is inventor of the Objectory OO method, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community. 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 standard CCITT/SDL. 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.
RELATED TUTORIALS: Tutorials 17 Architecture and Process for a Systematic Reuse-Driven Software-Engineering Business, 14 Techniques for Systematic Design of Graphical User Interfaces (For Highly Usable Systems) Based on Use Cases, and 26 High-Level Design With Use Case Maps, discuss related topics.
This tutorial will be repeated on Thursday afternoon.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM Wednesday PM
SPEAKER(S)/AFFILIATION: Nataraj Nagaratnam, Syracuse University
ABSTRACT: With Java(tm) making a significant impact on Web-based applications, it is becoming a necessity to know Java and its intricate details. Graphical user interface development is an integral part of developing web-based applications. This tutorial will provide details on building Java applets using the Abstract Window Toolkit (AWT) package provided with the JDK environment. Detailed coverage of applet construction, structure of AWT, the principal classes and methods necessary to develop GUIs and details of event handling in AWT will be covered in this tutorial. Examples will be used to explain the methods and the approaches discussed in the tutorial.
BACKGROUND: The tutorial is intended for developers interested in developing applets and graphical user interfaces. One should have an introduction to OO technology. In addition, familiarity with C/C++ syntax is a significant aid. Suited for developers interested in developing interactive, animated graphical user interface applications by exploiting the capabilities of the Java AWT package. The purpose of the tutorial is to familiarize the participants with applet construction and provide the necessary techniques to build a GUI in Java.
BIOGRAPHY: Nataraj Nagaratnam is a PhD candidate in Computer Engineering at Syracuse University. He is the lead author of "Waite Group's Java Networking and AWT API SuperBible" published by the Waite Group Press under Macmillan Publishing Company. His research interests span the areas of distributed object management and distributed runtime.
RELATED TUTORIALS: Tutorial Advanced Java -- Idioms, Styles, Programming Tips, and Pitfalls
This tutorial will be repeated on Wednesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Steve Mellor, Project Technology
ABSTRACT: The Shlaer-Mellor Method is the pioneering translative Object-Oriented method that supports complete model-based software development. By focusing on models instead of low-level coding languages, development teams dramatically decrease their development cycles. Model Compilers, created through the Recursive Design technique, provide the enabling technology for model-based development.
This session will focus on the internals of Shlaer-Mellor Model Compiler technology. This presentation will show a detailed and specific translation from an object-oriented analysis model into C++ code. The code will be constructed using a revolutionary technique called Recursive Design, a part of the Shlaer-Mellor Method. This approach is based on the construction of a Model Compiler that defines rules for the organization of data, control, and algorithm, and then a compilation or translation, via the model compiler, from the application analysis models directly into C++. Attendees will gain an understanding of how Model Compiler technology works, as well as the elements of performance tuning available to create high performance source code for real-time constraints.
BACKGROUND: Participants should have some general background and understanding in the Object-Oriented paradigm. Object-Oriented Analysis will be briefly discussed, and most of the focus will be in implementation via Recursive Design. Some knowledge of C or C++ will increase understanding of the example and allow the participant to focus on the design approach.
BIOGRAPHY: Stephen J. Mellor is best known in the software development community for his contribution to the development of Object-Oriented Analysis and to the Ward-Mellor modeling technique. He is a founder of Project Technology, Inc., where he serves as co-researcher, with Sally Shlaer, for Project Technology's extensions and applications of the Shlaer-Mellor Method. He is the co-author, with Sally Shlaer, of Object-Oriented Systems Analysis: Modeling the World in Data (1988), Object-Lifecycles: Modeling the World in States (1991). Steve and Sally are current writing their third book in the series, Shlaer-Mellor Method: Recursive Design (1996).
RELATED TUTORIALS:
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis,
37 The Unified Modeling Language
40 Application
of Object-Oriented Technology in Real-Time Embedded Systems
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
52 The
Semantics of The Unified Modeling Language
44 Responsibility-Driven
Design
46 Applying the
Unified Modeling Language
54 Real-Time Object-Oriented
Modeling
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM Wednesday PM
SPEAKER(S)/AFFILIATION: Kyle Brown, Knowledge Systems Corporation Bobby Woolf, Knowledge Systems Corporation
ABSTRACT: If you wanted to implement a window that looks like a calendar, could you do it? If you would like to develop a view to display a bubble-and-arrow diagram, would you know how? If not, but you would like to learn how, attend this tutorial. While the tutorial will primarily focus on Parcplace-Digitalk's VisualWorks and discuss how you can use its frameworks to implement your own graphical presentations, we will also provide examples from Visual Smalltalk and VisualAge. Attendees will receive additional notes that cover Visual Smalltalk and VisualAge in more depth. We will develop a Calendar View as a running example to illustrate the design and use of the graphics frameworks. In order to demonstrate the principles that went into the design of the graphics frameworks, we will 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.
BIOGRAPHY: Kyle Brown is the Associate Director of Transition Solutions 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, Smalltalk Solutions '95 and '96, and Object Expo Europe '95.
RELATED TUTORIALS: Tutorial 18 Efficient Smalltalk Programming also discusses Smalltalkdevelopment issues.
This tutorial will be repeated on Wednesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Arthur J. Riel
ABSTRACT: 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 conscience 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:
BIOGRAPHY: Arthur J. Riel has over twelve 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 tool co-developed at Northeastern University with Karl Lieberherr et al.), and a commercial library of reusable C++ components called Classix (Vanguard Software Incorporated). His current pursuits include the creation and use of good heuristics for object-oriented analysis/design and C++, the development and use of reusable object-oriented frameworks, and the development of object-oriented design patterns and their associated pattern languages. In addition, Arthur teaches more than forty courses (C++, OOA/D) per year in both corporate and academic environments. He participates in an additional 8-10 design critiques per year. Arthur Riel has published a text titled "Object-Oriented Design Heuristics" through Addison-Wesley (4/96).
RELATED TUTORIALS:
23 A Good
Architecture for Object-Oriented Information Systems: Structures, Designs,
and Patterns
24 How Do
You Tell the Difference Between a Good Design and a Bad Design.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Eric Jul, Univ. of Copenhagen
ABSTRACT: As computer networks become faster and cheaper, it becomes more and more desirable to use distributed computing. Object-oriented programming seems to mesh exceptionally well with the paradigms of distributed programming because of object encapsulation and the clean interface presented by an object.
The aim of this tutorial is to teach the basic ideas and paradigms of distributed object computing rather than a specific technology. As such this tutorial is a good lead-in for tutorials that address specific technologies, e.g. tutorials 35, 39, and 50.
Issues covered include:
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.
BIOGRAPHY: 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, heteorogenous 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 (distrbuted shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPLSA conferences he has run a number workshops tutorials related to distributed computing.
RELATED TUTORIALS:
35 OLE, CORBA
- Infrastructures for Distributed Object Computing
39 Introduction to CORBA
50 Object
Oriented Design Patterns for Concurrent, Parallel, and Distributed Systems
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30 8:30AM - 12PM - 12 PM
SPEAKER(S)/AFFILIATION: Michael Schwartzbach, University of Aarhus Jens Palsberg, MIT
ABSTRACT: This tutorial is based on the speakers' recent book: Object-Oriented Type Systems. It defines an idealized object-oriented language, inspired by Smalltalk, and teaches a coherent theory of object-oriented type systems. We cover the spectrum of types from traditional implementation-oriented types to interface types. A straightforward model of types as sets of classes is used to explain and generalize the type systems of conventional languages, such as C++, Simula, and Eiffel. Interface types will be explained together with the issue of covariance vs contravariance. Main topics include: the limitations of static type checking and the introduction of dynamic type checks; the interaction between types and mechanisms for inheritance and genericity; the influence of a type system on separate compilation; the use of type information for optimizations. Special emphasis is on algorithms for type inference. Type inference has been successfully implemented for languages as diverse as Self, Concert, and BETA, enabling greater efficiency through inlining of message sends, removal of dead code, and elimination of run-time checks. We give details of algorithms for type inference, both for types as sets of classes and for interface types.
BACKGROUND: Participants should be familiar with an object-oriented language and be interested in the problems faced by the designer of a type system. No mathematical formalism is used, but students should want to consider these issues independently of specific languages.
BIOGRAPHY: Michael Schwartzbach is associate professor in the BRICS Centre at the Department of Computer Science of the University of Aarhus. Jens Palsberg is visiting scientist at MIT. Michael received his Ph.D. from Cornell University in 1987; Jens received his Ph.D. from the University of Aarhus in 1992. We have published numerous papers on object-oriented languages and type systems, several of those at OOPSLA and ECOOP conferences. We have written the book Object-Oriented Type Systems, published by John Wiley & Sons, on which our proposed tutorial is partly based. We have previously given half-day tutorials at OOPSLA'92, ECOOP'93, OOPSLA'93, POPL'94, and OOPSLA'95. Michael is associate editor of the TAPOS journal. Jens has been on the program committees of ECOOP'94-96. We are guest editors on the recent special issue of the TAPOS journal on type systems.
RELATED TUTORIALS:
21 Typing
in Object-Oriented Languages: Achieving Expressiveness and Safety
49 A Theory of Objects
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Don Batory, University of Texas at Austin
ABSTRACT: Generators will become increasingly important tools for economically developing high-performance, customized software that is evolvable. Generators implement scalable domain models that define how software systems of a domain can be synthesized by composing components from reuse libraries.
GenVoca is an emerging paradigm for creating such generators. This tutorial explains its design principles, implementation techniques, and underlying assumptions. GenVoca generalizes object-oriented frameworks by encapsulating metadata refinements (i.e., before and after method wrappers of metaobject protocols) and by providing interface subjectivity (i.e., the ability of components to customize their interfaces automatically upon instantiation). We illustrate these concepts with case studies from database, communication protocol, avionics, file system, and data structure generators. We also explain how scalable models of domains are developed and present practical and efficient algorithms for validating compositions of components.
PREREQUISITES: This tutorial is aimed at researchers and practitioners who are faced with the problem of building families of software systems economically, and/or who are interested in assembling customized and evolvable software systems from reuse libraries.
BIOGRAPHY: Don Batory is an Associate Professor in Computer Sciences at the University of Texas at Austin. He was a member of the ACM Software Systems Award Committee from 1989-1994, an Associate Editor of ACM Transactions on Database Systems from 1986-1992, an Associate Editor of IEEE Database Engineering from 1981-1984, and the Program Committee Chairman for the 3rd International Conference on Software Reuse (November, 1994).
RELATED TUTORIALS: Tutorial 34 How to Develop Frameworks
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Michel Izygon, I-NET/NASA Johnson Space Center
ABSTRACT: In order to achieve large-scale reuse, an organization cannot rely only upon a programming language or a software development paradigm such as OO. That's the reason why over the past few years a number of Domain Analysis methods have been developed and used on some projects. These methods, which aim at allowing the analysis of a family of applications within a domain, have slowly come to maturity.
This tutorial will first explain the reasons why there might be a Domain Analysis method in the future of many organizations. Then, the tutorial will review different methods available and will provide help to the attendees in choosing the appropriate method for their needs while avoiding the pitfalls inherent to this specific technology. Examples and lessons learned from actual Domain Analysis efforts will illustrate these concepts.
BACKGROUND: Familiarity with at least one object-oriented analysis method.
BIOGRAPHY:
Michel Izygon has worked over the past six years at the NASA Johnson Space Center, responsible for inserting advanced software technologies such as CASE tools Object-Oriented Technology, Process Improvement, Domain Engineering methods. He has participated as a mentor to a large-scale reuse project, defining the Domain Analysis Process to be used, and helping the team execute this process. He has also been involved with the reengineering of a family of application simulating Solar Thermal Power plants. Michel Izygon has been using object technology for the past eight years, C++ for the past five years. He has taught Object-Oriented Analysis and Design Methods for the past four years, and Domain Engineering techniques for the past three years within NASA JSC.
RELATED TUTORIALS: 22 Applied Object-Oriented Analysis and System Design
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Timothy D. Korson, Software Architects, Southern College, and The Consortium forthe Management of Emerging Software Technologies (COMSOFT)
ABSTRACT: To facilitate the adoption of object technology, a number of organizations have set up a corporate Object Technology Center(OTC). Members of these OTCs attend the annual OTC conference and OOPSLA workshop series sponsored by the Consortium for the Management of Emerging Software Technologies (COMSOFT). This tutorial summarizes the results of these conferences and workshops as well as the consulting experiences of the author in helping organizations establish and sustain an OTC. Topics covered include how to set up, fund, and organize an OTC. Several different models of a successful OTC are presented and the activities of an OTC are explored and correlated with the goals and organizational structure of various types of OTCs.
BACKGROUND:
General familiarity with object-oriented technology and the problems involved in trying to infuse object technology into an organization.
BIOGRAPHY: Timothy Korson is a partner in Software Architects, the director of the Southern College Software Technology Center, and president COMSOFT, a non-profit consortium for OTCs. He is an organizer of OTC'96 and the annual OTC OOPSLA workshop series. He has helped several organizations establish and maintain an object technology center, and is a co-author of the forthcoming prentice hall book on OTCs: "Object Centers of Excellence", that will be released and on sale at OOPSLA '96. He has given previous versions of this tutorial at OOPSLA, OTC'95 and Object Expo.
RELATED TUTORIALS: Tutorials 31 Managing for Effective Use of Object Technology, and 51 The Manager's Role in a Successful Transition to Object-Orientation discuss other management topics.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Stefan Ahlqvist, Rational Software Scandinavia AB Patrik Jonsson, Rational Software Scandinavia AB
ABSTRACT: As the use of software systems has evolved to encompass almost every person in the western world, the need for usability has increased greatly. Since high usability increases the performance of the user, leading to more people using software systems, usability is today more important than ever before. Unfortunately, the only way of achieving high usability we have had, so far, is to use repeated prototype-use test-iterations, at a considerable cost both in terms of time and money. One key-reason behind this is that we have lacked a structured process geared explicitly towards designing highly usable GUIs.
This tutorial describes such a process based on Use Case Engineering techniques.This process is the result of more than one year's research at Objectory and Rational, conducted by a team consisting of Stefan Ahlqvist, Patrik Jonson and Dr. Ivar Jacobson. This process is planned to become an integral part of Rational Software Corporations configurable Software Engineering Process (SEP).
PREREQUISITES: Experience of information systems development and basic knowledge of object-orientation and graphical user interfaces.
BIOGRAPHY:
Stefan Ahlqvist received his M.Sc. in Computer Science from Linkopings Institute of Technology in 1987. He has since then spent most of his time on the development of user interface design techniques. In his work, he early became one of the key persons behind the development of one of the worlds most successful GUI builders for Motif, the "TeleUse" product. Stefan Ahlqvist has worked at Rational (former Objectory) since the beginning of 1995, doing research work on the novel process for systematic GUI design that is presented in this tutorial.
Patrik Jonsson works at Rational as a member of the process business unit. Being one of the first to join Objectory AB, he has been involved in several different activities, including customer projects, process and method development, specifying the requirements on the Objectory CASE tool and teaching. He is a co-author of the Addison-Wesley bestseller "Object-Oriented Software Engineering - A Use Case-driven Approach". Lately Patrik Jonsson has focused on large-scale reuse issues, but has also participated in defining a process for systematic GUI design part of which is presented in this tutorial.
RELATED TUTORIALS: Tutorials 48 User-Driven Strategies for Object-Oriented Development discuss issues related to user-interaction. Tutorials 4 Use-Case Engineering, and 17 Architecture and Process for a Systematic Reuse-Driven Software-Engineering Business, discuss related topics.
Back to OOPSLA '96 Tutorial Overview
Sunday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Maher Awad, Nokia Research Center. Jurgen Ziegler, Nokia Research Center. Laszlo Huray, Nokia Research Center.
ABSTRACT: This tutorial presents the OCTOPUS method which pushed out the boundaries of
object-oriented methods to provide a systematic and practical approach to real-time object-oriented software development.
The development of OCTOPUS was based on long-term practical experience at Nokia Corporation in addition to scientific research of object-oriented technology and real-time systems. It has been applied in a number of real projects in telecommunications and control systems, with far better results compared to other OO methods and to earlier conventional techniques.
The OCTOPUS method is based on the popular OMT and Fusion methods, but also embodies common practice found in real-time systems. It applies proven object-oriented techniques and enhances them, if necessary, to match the specific needs of real-time systems such as concurrency, synchronization, communication, handling of interrupts, hardware interfaces and end-to-end response times.
The OCTOPUS method supports incremental development and covers in a well-integrated approach requirements specification, system architecture, subsystem analysis/design, performance analysis and implementation issues specific to real-time systems. Unique features in the method include the state model, a balanced reactive and scheduled behavior, the hardware wrapper and the mapping of objects to processes in an optimal way to satisfy the required concurrency and responsiveness (time constraints) on the events in the application domain.
This tutorial helps embedded system engineers to quickly transit to learn and apply effective software engineering techniques in their projects and enables object-oriented software engineers to enter the real-time systems application domain.
Click here for more information about OCTOPUS.
PREREQUISITES: Participants should have a general familiarity with the object-oriented paradigm and real-time systems. Familiarity with a programming language will be useful, but not required.
BIOGRAPHY: Maher Awad has a B.Sc. degree from University of Jordan and a M.Sc. degree from Helsinki University of Technology, both in Electrical Engineering. Currently he pursues Ph.D. studies in embedded systems software engineering. He Has more than eight years of experience in developing real-time software for telecommunication products at Nokia Telecommunications and more recently at Nokia Research Center. He has also long experience in project management and hardware and ASIC design. He is presently the manager of object-oriented technologies for embedded systems area at Nokia Research Center. He managed and co-authored Object-Oriented Technology for Real-Time Systems, Prentice Hall, 1996.
Jurgen Ziegler has a M.Sc. degree in Computer Science from the University of Karlsruhe in Germany. He Developed real-time software for chemical instruments and managed development projects for almost ten years at Hewlett Packard Co. After that, he was responsible for the development of system software products at Nokia Data. Since joining the Nokia Research Center, he has worked on a company-wide initiative transferring object-oriented technology to embedded microprocessor products. He co-authored Object-Oriented Technology for Real-Time Systems, Prentice Hall, 1996.
Laszlo Huray has a Licenciate of Technology degree in Digital Techniques and an M.Sc. degree in Electrical Engineering from Technical University of Budapest, Hungary. He has twenty years of experience in developing real-time software for industrial control systems and telecommunication products at different Hungarian and Finnish companies and research institutes. He has also long experience in hardware design and project management. He is presently a senior research engineer at Nokia Research Center with focus on object oriented technologies and distribution in embedded systems.
RELATED TUTORIALS:
Tutorial 54 Real-Time Object-Oriented Modeling, also discusses issues in object-oriented real-time systems.
Tutorials 25
Working with Objects: Use and Reuse with Role Model Analysis andSynthesis,
42 The Semantics
of The Unified Modeling Language,
44 Responsibility-Driven
Design and
46 Applying the
Unified Modeling Language describe other analysis and design methods.
Back to OOPSLA '96 Tutorial Overview
Sunday PM Tuesday PM
SPEAKER(S)/AFFILIATION: Chris Laffra, Morgan Stanley
ABSTRACT:
This tutorial does not give an introduction to Java for novices. Instead, we concentrate on more advanced features, such as OO analysis and design for Java, multithreaded application development, naming of classes and interfaces, optimization techniques, equality testing, exception handling techniques, reflection in Java, hashtables, implementing callbacks, the cost of garbage collection, accessing methods of unconstructed objects, Java pitfalls and "gotchas", debugging of Java programs, automatically translating C++ code to Java, and the future of Java. The tutorial is based on the material discussed in the book "Advanced Java" published by Prentice-Hall. The software enclosed with the book and described in detail at this tutorial includes Ltk, (an alternative to AWT), A visual debugger for Java, and C2j (a C++ to Java translator).
BACKGROUND: This tutorial is targeted primarily at experienced Java programmers looking for insights into Java's more advanced features, things to be aware of, and Java pitfalls. Non-Java programmers (experienced with other OO languages) who are interested in languages, interpreters, compilers, and run-time systems may attend.
BIOGRAPHY: After receiving a Master's degree in Computer Science from the Free University of Amsterdam, the Netherlands, Chris has designed and implemented PROCOL, a parallel object oriented language as part of his PhD research at the Erasmus University of Rotterdam, the Netherlands. His interests during that time spanned OO languages, compiler techniques, and user interface development. During the two years he spent at the IBM T.J. Watson Research, Chris worked on a compiler and development environment for the Oberon language and developed HotWire, a platform independent visual debugger for C++ and Smalltalk. Some of his ideas can now be found back in commercial versions of the IBM Smalltalk system, VisualAge. In the summer of 1994, Chris moved to the information technology department of Morgan Stanley in New York City, to work on firm-wide infrastructure and user interface aspects of financial applications used by Morgan Stanley at Wall Street. Chris has also been actively involved in evaluation projects of the Java language inside Morgan Stanley, and ported major parts of MStk to Java. Chris has presented papers and organized various workshops at OO conferences such as OOPSLA, ECOOP, TOOLS, and Usenix-C++. He was demonstration chair and exhibition chair of ECOOP'92. He presented a tutorial at SIGGRAPH and co-chaired a Eurographics workshop on the topic of using OO techniques for graphics, leading to a publication by Springer Verlag. Chris is author of "Advanced Java", published by Prentice Hall. More information at: http://members.aol.com/laffra
RELATED TUTORIALS: Tutorial 5, "Developing GUIs using the Java AWT," also discusses implementation in Java.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Martin Griss, Hewlett-Packard Laboratories Ivar Jacobson, Rational Software Corporation Patrik Jonsson, Rational Software Corporation
ABSTRACT: 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 think that 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 assets, OO reuse will not succeed. In almost all cases of successful reuse, management support, simple architecture, a dedicated component group, a stable domain, standards and organizational support were the keys to success. These largely non-technical issues seem to be more important to successful reuse than the specific language or design methodology chosen.
We believe that this architecture/process/organization question can be addressed systematically. The tutorial will describe an exciting approach which applies Object-Oriented Business Engineering (OOBE) and 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 endeavour, 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 extended the OOSE process to support a form of domain engineering based on a business model of the target organization, with specific architecture and component factoring and clustering steps. Component and framework engineering should include 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. We recommend techniques to augment OO application frameworks with problem-oriented scripting languages, builders, and systems and component generators. to produce domain-specific kits that can handle the complexity inherent in frameworks with large numbers of classes and methods.
BACKGROUND: Experienced OO practitioners and software managers
BIOGRAPHY: Martin L. Griss is a senior Laboratory Scientist at Hewlett-Packard Laboratories, Palo Alto, where he researches object-oriented reuse and measurement system kits. 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 past director of the Software Technology Laboratory and has over 20 years in software engineering research. He was previously associate professor of computer science at the University of Utah. He has authored numerous papers and reports on software engineering and reuse, writes a reuse column for the Object Magazine and is active on several reuse program committees. He has given several half-day and full-day tutorials on systematic reuse, and object-oriented reuse. Griss is a frequent invited or keynote speaker at numerous executive level software symposia and workshops, discussing software reuse as a strategic software activity.
Ivar Jacobson is inventor of the Objectory OO method, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community. 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 standard CCITT/SDL. 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.
Patrik Jonsson joined the reuse-business project to help Ivar capture and formulate his ideas, and has been a major participant, synthesizing ideas from Ivar and Martin, and adding numerous ideas of his own. Patrik Jonsson works at Rational as a member of the process business unit. Being one of the first to join Objectory AB, he has been involved in several different activities, including customer projects, process and method development, specifying the requirements on the Objectory CASE tool and teaching. He is a co-author of the Addison-Wesley bestseller "Object-Oriented Software Engineering - A Use Case-driven Approach"
RELATED TUTORIALS:
4 Use-Case Engineering
19 Techniques
for Systematic Design of Graphical User Interfaces Based on Use Cases
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Ken Auer, Knowledge Systems Corporation
ABSTRACT: There is a lot of misinformation about the efficiency of Smalltalk. Unfortunately, the misinformation is often sprinkled with truth. Smalltalk does have some performance and space penalties. Yet, what is less understood is the exact nature of those penalties. Even less understood is the fact that performance and space problems in a Smalltalk application are often easier to overcome than in more traditional environments.
An overview of the myths, realities, and half-truths about Smalltalk and its efficiency is briefly addressed in this presentation. The rest of the presentation focuses on detailed descriptions of the techniques used to overcome both speed and space problems. Detailed examples are used throughout.
PREREQUISITES: Participants should be experienced Smalltalk programmers
BIOGRAPHY: Ken Auer is the Director of Applied Technology at Knowledge Systems Corporation (KSC). Mr. Auer has successfully applied his skills and experience in object technology to a variety of industrial projects and organizations since 1985. He has been involved in projects ranging from small prototypes to large distributed, multiple OO language systems and teams ranging from individual developers to large IS organizations. He currently serves on the editorial board of Object Magazine and is a founding member of The Hillside Group.
RELATED TUTORIALS: Tutorial 7 Understanding Smalltalk Graphics also discusses Smalltalk development issues.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Wolfgang Pree, Johannes Kepler University Linz Hermann Sikora, RACON Software, Inc.
ABSTRACT: Design patterns support the development and reuse of extensible OO software components. They represent a complimentary enhancement of existing OO analysis and design (OOAD) methods. The tutorial gives an overview of state-of-the-art design patterns approaches, focusing on those that support the development of frameworks. The tutorial also introduces so-called hot spot cards. These cards proved to be a useful communications vehicle between domain experts and software engineers in order to exploit the potential of design patterns. Hot spot cards help in the early development phases to capture those system aspects that have to be kept flexible. Case studies illustrate how to apply hot spot cards together with design patterns in various commercial application domains including bank-specific systems, reservation systems and point-of-sale systems in retail trade stores.
BACKGROUND: Familarity with basic concepts of the object-oriented programming paradigm. Practical experience with object-oriented design is helpful.
BIOGRAPHY: Wolfgang Pree is an Associate Professor of Applied Computer Science at the University of Linz, Austria. Consulting and teaching in the realm of object-oriented software design and development was done for numerous companies in Europe and the U.S. He is the author of "Design Patterns for Object-Oriented Software Development" (Addison-Wesley/ACM-Press, 1995) and of "Framework Patterns" (SIGS Books, NYC, 1996).
Hermann Sikora is a managing director of RACON Linz Software, Inc., a company owned by and producing software for the largest private bank consortium in Austria, ranging from classic host-based systems to state-of-the-art client/server solutions. One of the most ambitious projects focuses on the design and development of a bank domain-specific framework. Sikora holds a Ph.D. in computer science and a degree in management information systems.
RELATED TUTORIALS: Tutorials 3 An Introduction to Design Patterns, 29 Design Patterns Applied, and 50 Object Oriented Design Patterns for Concurrent, Parallel, and Distributed Systems also discuss design patterns.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: James J. Odell, Quoin, Inc.
ABSTRACT: With so many OO analysis and design approaches, it is difficult to choose any one particular approach. Furthermore, each approach has useful diagramatic elements that other do not. However, upon closer examination, most approaches are fundamentally the same. This tutorial begins by examining and formalizing the fundamental notions common to all OO approaches. With such a formal foundation in place, then, useful ways of extending this foundation are discussed at length. These include n-level meta-modeling, constraint specification, natural language business-rule specification, power types, forms of composition, and situational method engineering.
BACKGROUND: While this tutorial proceeds from first principles, it goes into depth at a fast pace. The audience should be experienced in using one or more OO analysis and design modeling techniques. The attendees that benefit the most are well-seasoned system modelers and meta-modelers with a background in mathematics.
BIOGRAPHY:
James Odell is an IT consultant and practitioner specializing in the object-oriented approach. Throughout most of his 25 year career, he has been heavily involved in developing better methods to manage, understand, and expresssystem requirements. He was one of the early innovators of data and process modeling, and information engineering methodologies. Now, he is one of the first practical implementors of object-oriented modeling and implementation--consulting to major companies worldwide. He is a very experienced and highly-regarded educator and speaker. James Odell is the author of three books on OO and has also written numerous papers and articles on the subject.
RELATED TUTORIALS: Tutorials 52 The Semantics of The Unified Modeling Language, and 53 Advanced Class Interface Design and Programming by Contract also discuss advanced topics in analysis and design.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Kim B. Bruce, Williams College
ABSTRACT: Static typing aids in earlier error detection, supports compiler optimizations, and provides information to programmers on the intended use of constructs. However, simple static-typing disciplines for object-oriented languages like C++, Java, and Object Pascal are so restrictive that programmers are forced to by-pass the type system with type casts. Other languages allow more freedom, but require run-time checking to pick up the type errors that their more permissive systems missed.
After surveying problems with existing type systems (illustrated by a series of sample programs), we suggest ways of improving the expressiveness of these systems while retaining static type safety. New constructs introduced include "MyType", "matching", and "bounded matching" (a form of bounded polymorphism). We include a brief discussion on how the type system and semantics ensure type safety. The focus of the tutorial is on the application of the theory, not the development of it.
BACKGROUND: Attendees should be very comfortable with the concepts of and programming in class-based object-oriented programming languages and experienced with static typing systems. Frustration with the rigidities of statically-typed object-oriented languages will be a helpful motivator. The tutorial is aimed at programmers who would like the flexibility of weakly or dynamically typed languages, but the error detection and efficiency of statically-typed languages, as well as language designers and others who would like to see the applications of type theory to language design.
BIOGRAPHY: Kim Bruce is Wells Professor of Computer Science at Williams College in Massachusetts, USA. He received his B.A. from Pomona College and Ph.D. from the University of Wisconsin. He taught at Princeton University before coming to Williams, and has been a visiting professor or scientist at M.I.T., Stanford, Ecole Normale Superieure, the University of Pisa, and the Newton Institute for Mathematical Sciences at Cambridge University. He has worked on the semantics of object-oriented languages for the last 10 years, and provably-safe type systems for object-oriented languages for the last 5 years. He has served twice on the OOPSLA program committee, and has been co-organizer of workshops on the Foundations of Object-Oriented Languages in 1993, 1994, and 1996. He has presented papers at the ECOOP, OOPSLA, POPL, MFPS, and LICS conferences, and currently serves on the editorial boards for TAPOS and the forthcoming CRC Handbook of Computer Science and Engineering.
RELATED TUTORIALS: Tutorials 10 Types for the Language Designer, and 49 A Theory of Objects also discuss language typing issues.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Ed Seidewitz, Millennium Systems, Inc.
ABSTRACT: This is not just another tutorial on yet another object-oriented methodology. This is a tutorial about the underlying principles and real-world practical application of object orientation. It is intended for developers embarking on, or in the midst of, their first major object-oriented development project. The objectives of the tutorial are to reinforce the student's foundation in fundamental object-oriented concepts, to give good examples of the application of object-oriented analysis and design techniques and formalisms and to enable the student to transfer this knowledge the student's actual project work. The tutorial presents fundamental concepts, textual and graphical notation and proven problem-solving techniques for object-oriented analysis and system design, such as use cases, domain analysis, event-trace analysis, state-transition analysis and architectural design. The focus is on the sensible use of notation, formalism and process in laying the foundation for reliable object-oriented software.
BACKGROUND: Participants should have a basic knowledge of object-oriented concepts, particularly as they apply to object-oriented analysis and design methods. Having read a book on or taken a tutorial in any one of the popular object-oriented methodologies would be sufficient.
BIOGRAPHY: Ed Seidewitz is president and owner of Millennium Systems, Inc., specializing in object-oriented software engineering, training and consulting. He has taught highly successful professional development courses in object-oriented analysis, object-oriented design and Ada programming and consulted on commercial, government and military projects. Until recently, Mr. Seidewitz also worked in the Flight Dynamics Division at NASA's Goddard Space Flight Center. He is now Chief Engineer at DHR Technologies.
Mr. Seidewitz has been active in the object-oriented methods and Ada communities for over ten years. He has been Chair of the Washington DC Chapter of the ACM Special Interest Group on Ada, Conference Chair and
Program Chair of the Washington Ada Symposium and on the Conference Committee for the 1993 Object-Oriented Programming Systems, Languages, and Applications conference. He was a contributor to the object-oriented features of Ada 95. He also has a background in the analysis and specification of aerospace systems, particularly state estimation and error analysis for spacecraft navigation. Mr. Seidewitz has two bachelors of science degrees from the Massachusetts Institute of Technology, one in Aeronautics and Astronautics and one in Computer Science and Engineering.
RELATED TUTORIALS: Tutorial 12 Reuse Engineering: Inserting a Domain Analysis Method in an Organization also discusses topics relating to domain analysis.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Mark L. Fussell, Consultant
ABSTRACT: Without a good architecture, a software system is hard to understand, predict, manage, and optimize. When a project team does not develop and maintain a good architecture, they are increasing the risk of the project's failure. Fortunately, almost all commercial Object-Oriented Information Systems can be built using a fairly simple, well-structured architecture built with common design patterns. This tutorial presents a simple and good architecture for building an OOIS along with the detailed designs to help implement the system in developed or purchased software. By following this architecture, a project team will overcome one of the major problems that can prevent it from success and it can focus on managing the rest of the project's high risk areas.
BACKGROUND: This tutorial is targeted at project leaders and developers who are building information systems using an object oriented development environment. The audience should be comfortable with OO design and with basic system architecture terms like subsystems and interfaces. Familiarity with design patterns, UI frameworks, or database frameworks will be helpful.
BIOGRAPHY: Mark L. Fussell has been developing applications, frameworks, and architectures for information systems for more than ten years. In the last several years he has focused on identifying the frameworks and a sound overall architecture to support large project teams building complex OO systems as well as small project teams trying to quickly develop simpler systems. The types of projects he has worked on include Health Care, Shipping, Social Service, and Political/Military information systems.
RELATED TUTORIALS: Tutorial 8 Object-Oriented Design Heuristics and Their Relationship to Design Patterns discusses related design pattern issues.
Back to OOPSLA '96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Douglas W. Bennett, IBM Methodology Architecture Group
ABSTRACT: There are lots of claims made for the benefits of object-oriented programming and there is lots of advice available on how to "do" object-oriented software design. There are not many ways to determine if the benefits are really there, nor is there much advice on how to know whether it is good or bad. Architecture is key to designing for properties like maintainability and reusability. This tutorial will present an architecture definition and a set essential analysis and design tasks, with work products, needed to get from system scope to a specification of the architecture. The focus will be on evaluating each work product to demonstrate that the desired system properties have, in fact, been designed in to the system. Students will evaluate alternate documents for each task, including the system architecture. This is not a tutorial on development process. It is a tutorial on how to use the tools and gauges of the software engineering trade.
BACKGROUND: The tutorial is targeted at people who are responsible for determining the size, shape and content of software systems. Participants should have some experience engineering software and should be comfortable working with design documents. Experience with at least one methodology would be very helpful.
BIOGRAPHY: Doug Bennett has been engaged in training and consulting in object technology and software stem design since 1987. Before that he had four years programming and teaching experience. Before entering the software industry he was a chemical engineer for 12 years. His focus has been on how to design systems that will deliver on the promises made by the technology vendors. He as participated in the design of telephone switches, and commercial applications in banking, insurance and finance.
RELATED TUTORIALS: Tutorial 8 Object-Oriented Design Heuristics and Design Patterns also discusses related design topics.
Sunday PM
SPEAKER(S)/AFFILIATION: Trygve Reenskaug, University of Oslo and Taskon Odd Arild Lehne, Taskon
ABSTRACT: The tutorial tells you how to use a powerful object abstraction: The OOram role model. Practical object models are often very complex. We show you how to divide and conquer by separating out different areas of concern by identifying use cases and system activities. Each area of concern is describedas a pattern of interacting objects. The object pattern is abstracted into a rolemodel that shows how the objects play certain roles in the context of the chosenarea of concern.
We also show how you can synthesize composite models by specifying how objects are to play several roles from different role models. This provides the key to systematic reuse. Base role models show how objects interact to performdifferent activities; a derived model shows precisely how these activities areperformed in a complete system.
We finally show how the basic technology permits you to create large systems in small projects by a policy of systematic reuse of proven models and programs (frameworks).
This tutorial is based on earlier tutorials, particularly tutorials presentedat OOPSLA '95, '92, and '90; and on "Working with objects", a book written bythe speakers and published by Prentice Hall.
BACKGROUND: Participants should be conversant with the object paradigm and have some experience with object oriented programming. The tutorial does not assume prior knowledge of any analysis and design method, but it will be of particular interest to people who are searching for a method that supports large scale development and that encourages the creation and systematic reuse of proven components.
BIOGRAPHY:
Trygve Reenskaug has 35 years experience in developing industrial strength software products combined with software engineering research. He has extensive teaching experience including several OOPSLA tutorials. He is co-founder of Taskon and is its vice president for research. He is professor of informatics at the University of Oslo. 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; and experimental Model-View-Controller -- the world's first reusable object-oriented framework -- while visiting scientist at Xerox Palo Alto Research Center in 1979.
Odd Arild Lehne has more than 10 years experience in the object-oriented paradigm. He has teaching experience from several courses in the OOram method, including teaching the OOram method at the Norwegian Institute of Technology. He is co-founder of Taskon, and is Product Manager for use of the OOram method in the customer organizations. The last four years he has been working as a consultant in the object-oriented area. He has experience from several european software development projects (ESPRIT / EUREKA) using object-orientation as a framework. He is member of the board of the Norwegian Computer Society.
RELATED TUTORIALS: Other analysis and design method tutorials:
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
37 The Unified Modeling Language
40 Object Models:
Strategies, Patterns, and Applications
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
52 The Semantics
of The Unified Modeling Language
44 Responsibility-Driven
Design
46 Applying the
Unified Modeling Language
54 Real-Time Object-Oriented
Modeling
Sunday PM
SPEAKER(S)/AFFILIATION: R.J.A. Buhr, Carleton University
ABSTRACT: Modern software increasingly embodies a combination of object-oriented and real-time characteristics. To make object-orientation work for systems with real-time characteristics, we need a way to reason from real-time requirements to object-oriented solutions. Use case maps replace design magic and wasteful cut-and-try methods with a rational and traceable progression from use cases to system architectures to object-oriented implementations. The approach positions use case maps as follows: as part of a high-level bridge between requirements and detailed design (the main other part is high-level class relationship diagrams); as an architectural patterns language that combines behaviour and structure in a high-level way, helpful for evaluating design tradeoffs; as a framework for "plugging in" detailed gang-of-four-style design patterns. This tutorial explains the essence of, but does not depend on, a recent book "Use Case Maps for Object-Oriented Systems", Prentice Hall, 1996. The objective is to present enough of the essence of the principles, notations and techniques of the approach to give attendees an understanding of what it is, where it is applicable, how it can be used to supplement other methods, how to begin applying it, and where to find detailed guidance on how to apply it.
BACKGROUND: The bottom line is that attendees should have backgrounds that make them ready to deal with issues in high-level design and architecture, at a level above implementation details, across the range from object-oriented programs to real-time systems.
Necessary object-oriented background is general knowledge of object-oriented principles at an intermediate level and specific knowledge of at least one object-oriented language and one textbook design method. Which one does not matter, because this specific knowledge is required only to provide a base of technical sophistication, not as a starting point for the course material. Necessary real-time background is familiarity with issues of decentralized control, distributed operation, concurrency, dynamically-changing structure, continuous operation in the presence of failures, and good performance in the presence of unpredictable loads. Such background may come from courses, from books, from implementation experience, from design experience, or simply from general exposure to issues in some working environment.
BIOGRAPHY: Ray Buhr is a Professor of Systems and Computer Engineering at Carleton University in Ottawa. He holds a Ph.D. in control engineering from Cambridge University. His current research interests include object-oriented design of real-time systems, visualization of complex software, software architecture, and formal methods underlying design techniques. He has strong research, teaching, and consulting links to industry extending over many years and continents. He has published four textbooks on design, the most recent of which is the basis for this tutorial, and a number of papers on design.
RELATED TUTORIALS:
4 Use-Case Engineering
17 Architecture
and Process for a Systematic Reuse-Driven Software-Engineering Business
14 Techniques
for Systematic Design of Graphical User Interfaces (For Highly Usable Systems)
Based on Use Cases
Back to OOPSLA' 96 Tutorial Overview
Sunday PM
SPEAKER(S)/AFFILIATION: Bill Opdyke, Lucent Technologies - Bell Labs Innovations Don Roberts, University of Illinois at Urbana-Champaign
ABSTRACT: Are all your assignments "fresh starts", where there are no backward compatibility concerns, you understand the application domain well, and your funder will pay until YOU are satisfied with the results?
More likely, your job may involve extending an existing software system, with a less-than-complete understanding of what you are doing, while under schedule pressures to produce!
This tutorial discusses refactoring, a means for restructuring an object oriented program (within individual classes, inheritance hierarchies, aggregations or more generally among collaborating classes) to extend functionality and rapidly accommodate change. Refactorings can be applied to separate out parts of a program (design abstractions, reusable components) to make the design clearer and to make it easier to add new features.
We will focus on how to perform refactorings in both C++ and Smalltalk and how to solve problems that arise in each environment - including examples taken from real-world programs.
BACKGROUND: Participants should have a general familiarity with the object-oriented paradigm, preferably being fluent in one or more object-oriented languages. Familiarity with C++ or Smalltalk will be useful, but not required. The intended audience is professionals charged with developing or managing object-oriented applications.
BIOGRAPHY: Bill Opdyke is a member of technical staff at Lucent Technologies - Bell Labs Innovations (formerly AT&T Bell Laboratories). Bill's doctoral research at the University of Illinois focused on refactoring C++-based object-oriented frameworks, supervised by Ralph Johnson. At Bell Labs, Bill has focused on intelligent network and decision support applications of object-oriented technology. He is currently involved in platform planning for telephony applications.
Don Roberts is a PhD student under Ralph Johnson and has been studying refactoring for the past four years with an emphasis on dynamic environments such as Smalltalk.
RELATED TUTORIALS: Tutorials 30, "Object-Oriented Rapid Prototyping," and 31, "Testing Object-Oriented Software Systems," discuss other object-oriented development issues.
Sunday PM
SPEAKER(S)/AFFILIATION: Desmond F. D'Souza , Petter Graff, ICON Computing
ABSTRACT: Much of object-oriented design is about division of responsibilities and the specification of collaborations between objects, from the system/use-case level down to code. Frameworks are themselves compositions of such patterns, and using frameworks is greatly aided by a clear and precise descriptions of these patterns. We describe a set of effective modeling tools which introduce precise notions of interface, type, class, object, collaboration, role, generics, and pattern composition.
This tutorial will describe these tools to capture key aspects of design patterns in a way which is both abstract and precise, based on selected advanced modeling techniques from the Catalysis method. Catalysis combines strengths in requirements analysis and specification with a serious treatment of "pattern" composition, refinement, and architectural design. More detailed descriptions of these may be browsed at http://www.iconcomp.com.
BACKGROUND: Attendees should be familiar with object modeling and programming, design patterns as defined by Gamma et al, and use-cases. Those using or intending to use patterns with the Unified Method or Fusion, seeking clearly defined semantics of models, composition, and refinement, and those looking for design methods suited for newer languages like Java, will benefit. Familiarity with OOP language features vs. abstract system models a plus.
BIOGRAPHY: Desmond D'Souza is the president of ICON Computing, Inc. and a member of the faculty at the Software Quality Institute at the University of Texas at Austin. Mr. D'Souza publishes and speaks regularly at various object forums, and has used object technology since 1985. He is an author of the Catalysis method, writes the Education and Training column in the Journal of Object-Oriented Programming and in Report on Object Analysis and Design. He may be contacted at dsouza@iconcomp.com
Petter Graff is the Director of Technology and Applications at ICON Computing. He has worked with object technology since 1989, and has experience with using several methods and OO languages. Petter has presented tutorials on advanced modeling and design techniques at conferences, and has published articles on model integration. He can be contacted at petter@iconcomp.com
RELATED TUTORIALS: Other analysis and design method tutorials:
40 Object Models:
Strategies, Patterns, and Applications
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
37 The Unified Modeling Language
52 The
Semantics of The Unified Modeling Language
44 Responsibility-Driven
Design
46 Applying the
Unified Modeling Language
54 Real-Time Object-Oriented
Modeling
Back to OOPSLA '96 Tutorial Overview
Monday Full Day
SPEAKER(S)/AFFILIATION: Erich Gamma, IFA Consulting Richard Helm, IBM Consulting John Vlissides, IBM Research
ABSTRACT: 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 design patterns throughout the software development lifecycle, including:
o Initial design o Redesign and maintenance o Debugging, testing, and tuning o Communication and documentation
The tutorial takes students through the thought processes 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.
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.
BIOGRAPHY: Erich Gamma has been discovering and working with design patterns for the past seven years. Currently, Erich is a Senior Object Technology Consultant at IFA in Zurich, Switzerland. Prior to joining IFA he designed and implemented frameworks at Taligent. Before Taligent he was with the UBILAB research laboratory of Union Bank of Switzerland, where he was one of the architects of ET++, a comprehensive class library for developing interactive graphical applications. Erich has a Ph.D. in Computer Science from the University of Zurich.
Richard Helm is a consultant with the IBM Consulting Group in Sydney, Australia. His prior positions include Senior Technology Consultant with DMR Group and a member of the research staff at IBM T.J. Watson Research. He has applied design patterns to the design of several commercial systems. Richard has numerous international publications and is a past OOPSLA program committee member. Richard has a Ph.D. in Computer Science from the University of Melbourne, Australia.
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. He writes the "Pattern Hatching" column for the _C++ Report_.
The presenters are co-authors, along with Ralph Johnson, of _Design Patterns: Elements of Reusable Object-Oriented Software_.
RELATED TUTORIALS:
3 An Introduction to
Design Patterns
19 Application
of Design Patterns in Commercial Domains
Back to OOPSLA '96 Tutorial Overview
Monday Full Day
SPEAKER(S)/AFFILIATION: John L. Connell, Sterling Software at NASA Ames Research Center
ABSTRACT: There are few arguments about the validity of rapid prototyping as a requirements discovery approach, but there are also few published descriptions of exactly what that means or how to do it. Mr. Connell has more than a decade of experience on dozens of successful rapid prototyping projects. He has distilled that experience into a step by step formalization of the object-oriented rapid prototyping approach in his Yourdon Press series book, "Object-Oriented Rapid Prototying." This tutorial provides how-to directions for developing, iterating, refining, and evolving an OO prototype into a deliverable software application. This tutorial is not about hacking, nor is it about specifying a system to death before getting on with prototyping. It is about how the object-oriented rapid prototyper can walk the high middle ground, producing a high-quality, clearly-documented, easily-maintainable product that provides optimum user satisfaction with minimum effort. Learn how to accomplish what used to take several years with many software engineers and several layers of management, in several months with a handful of object-oriented rapid prototypers.
BACKGROUND: A computer science background is helpful but there are no specific programming language or design method knowledge requirements.
BIOGRAPHY: John Connell has broad software project management experience in a variety of government contracting and commercial environments covering all aspects of software engineering. He is senior author of two Yourdon Press books, Structured Rapid Prototyping, 1989, and the newly released, Object-Oriented Rapid Prototyping, 1995. He has delivered many popular public seminars on software engineering in major cities world-wide for the last ten years and is currently providing consulting on object-oriented software engineering for many successful development projects concurrently at NASA Ames where he is Chief Software Engineer for Sterling Software.
RELATED TUTORIALS: 42 Designing High-Performance Reusable Code discusses related object-oriented implementation issues.
Back to OOPSLA '96 Tutorial Overview
Monday Full Day Tuesday Full Day
SPEAKER(S)/AFFILIATION: John D. McGregor, Clemson University and Software Architects
ABSTRACT: This tutorial has two major goals. First it will present techniques for building components that are testable. Second, it will present techniques and a process for testing the components built as part of a project that uses object-oriented techniques.
The tutorial is divided into three parts: (1) specific techniques and small examples to illustrate specific testing algorithms; (2) a case study of a small set of classes and the infrastructure required to test them; (3) a process for component testing and a context of a complete testing process for object-oriented systems.
The techniques presented in the tutorial are intended to provide a scalable process that can be tailored to the size of a project and the degree of coverage required by the application. The comprehensive test plan, presented in the tutorial, integrates the construction process and the testing process to produce an efficient and complete development process.
BACKGROUND: This tutorial assumes experience in the use of object-oriented development methods. It also assumes a typical developer's knowledge of unit testing techniques. The examples used in the tutorial use C++ syntax; however, the discussion of the testing
approach provides sufficient context for experienced developers to understand the example even if they do not read C++.
BIOGRAPHY: 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" published by Van Nostrand Reinhold.
RELATED TUTORIALS: Tutorials 18 Efficient Smalltalk Programming and 42 Designing High-Performance Reusable Code discuss related object-oriented development issues.
This tutorial will be repeated on Tuesday.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Frank Buschmann, Siemens AG
ABSTRACT: We first give a short introduction to patterns. We then present several patterns at different levels of granularity. Patterns at the architectural level are Presentation-Abstraction-Control - an alternative to MVC - and Microkernel. Patterns at the design level include Command Processor and View Handler. For the idiom level, we give an overview on the available work and present the Counted Pointer idiom for C++ as an example. Furthermore, we discuss how these patterns use or build upon other well-known patterns. To show how patterns help with building high-quality software, we present a concrete real-world example, a material flow control system for manufacturing. We further discuss our experiences in pattern-minig and pattern-writing. The tutorial concludes with an overview on the pattern community.
BACKGROUND: Sound understanding of object-oriented concepts. Foundations of software architecture. Knowledge of the GoF patterns.
BIOGRAPHY: Frank Buschmann is a software engineer at Siemens Corporate Research and Development in Munich, Germany. He is responsible for the research activities on patterns and involved in a development project building an object- oriented framework for warehouse management. Frank was member of the C++ standards committee and the ESPRIT-III project REBOOT (REuse Based on Object-Oriented Techniques). Frank is member of the Hillside pattern group and conference chair of EuroPLoP '96. Together with colleages he is writing the soon-to-be-published book "Pattern-Oriented Software Architecture" (Wiley and Sons Ltd.). Frank is a regular columnist for Object Expert (SIGS UK) and OBJEKTspektrum (SIGS Germany). He organized workshops on patterns at ECOOP 94 and 95, and held tutorials and presented papers on reuse and patterns at various conferences including ECOOP, TOOLS, Object Technology, OOP, ICSR, and ObjectExpo London.
RELATED TUTORIALS: Tutorials 3 An Introduction to Design Patterns also discusses design patterns.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Eric Gold, Gold Objects Inc. Livleen Singh, Gold Objects Inc.
ABSTRACT: This tutorial is intended for C++ programmers who wish to learn Smalltalk as a second language. The object skills of these programmers go a long way towards learning Smalltalk, but their C++ background could cloud their understanding of the culture, philosophy, and nuances of Smalltalk. The tutorial emphasizes Smalltalk issues most likely to be foreign to a C++ programmer; it will not cover material that a C++ programmer already knows and will quickly cover material judged east to learn by such a programmer. The tutorial is divided into sections on culture, design, implementation, and style.
BACKGROUND: This tutorial is intended for strong C++ programmers. There now exists a significant number of programmers who have been exposed to C++ for many years. As a result, they are likely candidates for projects that require quick Smalltalk-based prototypes or projects based entirely in Smalltalk. Other attendees may only wish to broaden their understanding of object technology by learning an array of object languages.
BIOGRAPHY: Eric Gold is President of Gold Objects, Inc., which provides a broad array of organizations with object-technology solutions. Mr. Gold's professional experience includes independent consulting with numerous Fortune 500 organizations, as well as permanent corporate positions including Morgan Stanley and IBM's Object Technology Practice. He has authored more than a dozen scholarly publications, and has presented his work at conferences such as OOPSLA and the meetings of the Society for Judgment and Decision Making. Mr. Gold is a part-time doctoral candidate at Carnegie Mellon University in Decision Sciences, where he completed the MS degree in Decision Sciences and the MS degree in Statistics. He also holds an MS degree in Computer Science from Yale University and an MS degree in Experimental Psychology from the University of Oregon.
Livleen Singh is a recognized expert on C++ and object-oriented programming and design. He was the Editor-in-Chief of The C++ Journal for four years; The C++ Journal is a technical journal distributed to over 20,000 readers worldwide. Livleen has also authored and presented many articles and courses on C++ and object-oriented programming at all levels. He was also the principle designer and implementor of the WOOLIC++ library (Windows Object-Oriented Library in C++), the first GUI-based C++ library for MS-Windows and was the Director of Research and Development for a company that produced many well-known software development tools.
RELATED TUTORIALS: Tutorial 7 Understanding Smalltalk Graphics discusses graphics in Smalltalk, and Tutorial 43 The (Upcoming) Standard C++ Library discusses topics of interest to C++ programmers.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Ralph E. Johnson, University of Illinois at Urbana-Champaign
ABSTRACT: This tutorial will describe a process for developing frameworks. The process is driven by examples, which are used both to design a new framework and to document it when it is finished. A framework is developed by generalizing and abstracting from examples. The tutorial will show how standard design transformations are used to generalize existing systems, making them more reusable and abstract. It will discuss how to choose examples, how to manage the iteration that seems to be an inevitable part of framework development, and the importance of common design patterns that arise as a framework is being developed. Developing a framework is expensive, but it is valuable. This tutorial will help you to estimate the costs involved in developing a framework. It will frankly discuss problems in paying for framework development, though unfortunately it does not offer any easy solutions.
BACKGROUND: Attendees should know what a framework is and should have used at least one framework, such as a user interface framework like Model/View/Controller or InterViews or an application framework like MacApp or ET++. MFC counts, too.
BIOGRAPHY: For the past 10 years, Prof. Johnson has been studying object-oriented technology and how it changes the way software is developed. He has been involved in the development of an object-oriented operating system (Choices), compiler (Typed Smalltalk), graphics editor framework (HotDraw), music synthesis system (Kyma), and is currently working on a framework for accounting. He is a coauthor of "Design Patterns: Elements of Reusable Object-Oriented Software". He is on the faculty of the Department of Computer Science at the U. of Illinois at Urbana-Champaign and has helped organize several OOPSLA's, including OOPSLA'93 as program chair.
RELATED TUTORIALS:Tutorial 3 An Introduction to Design Patterns introduces the concept of design patterns. Tutorial 11 Software System Generators, Architectures, and Reuse discusses topics related to frameworks.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Michael Stal, Siemens AG Uwe Steinmueller, Siemens AG
ABSTRACT: The tutorial introduces the basic concepts and ideas behind Distributed Object Computing as well as the problems being solved with DOC technologies. We then present existing infrastructures for distributing objects across process boundaries. In detail, we focus on the standards of the Object Management Group such as CORBA, IBM SOM/DSOM and CI Labs OpenDoc. Further- more on the standards available from Microsoft such as the Component Object Model and OLE (Object Linking & Embedding). We will explain how Java and the Internet fit into Distributed Object Computing. The tutorial will also give an overview of the similarities and differences between existing platforms.
BACKGROUND: Sound understanding of object-oriented concepts Understanding of distribution
BIOGRAPHY: Michael Stal and Uwe Steinmueller are software engineers at Siemens Corporate Research and Development in Munich, Germany.
Michael Stal is responsible for the research activities on Distributed Object Computing at Siemens R&D and is involved in projects applying DOC technologies in various Siemens business units. Previously he worked in several development and research projects on object-oriented technology, distribution and software architecture. He is member of the C++ standards committee as well as the Object Management Group. Michael is member of the programm committee for the Usenix COOTS '96 conference (programm chair: Prof. Doug Schmidt) and the Software Devcon '96 (SIGS conference). Together with colleages he is writing the soon-to-be-published book "Pattern-Oriented Software Architecture" (Wiley and Sons Ltd.). Michael is a regular columnist and member of the editorial board for OBJEKTspektrum (SIGS Germany). He is co-editor of the German magazine JavaSpektrum. In the past he gave tutorials and papers on Object-orientation and distribution at various conferences including OOP, TOOLS, and Object Expo.
Uwe Steinmueller is involved in development projects for introducing Componentware with OLE in Siemens business units. Previously he worked at Siemens-Nixdorf, where he was responsible for implementing the C++ class library Generic++. He was one of the chief architects of NEDIS, a commercial business framework. Uwe is a former member of the C++ standards committee, where he submitted the standard String class. He is currently researching Java and its relevance for industrial software development. Uwe gave tutorials at various conferences such as OOP and TOOLS.
RELATED TUTORIALS: Tutorials that discuss issues related to distribution
of objects:
9 Introduction
to Distributed Computing Using Objects
39 Introduction to CORBA
50
Object Oriented Design Patterns for Concurrent, Parallel, and Distributed
Systems
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Dr. Mohamed E. Fayad, University of Nevada
ABSTRACT: This tutorial is based on our experiences in applying several object-oriented development techniques (e.g., OMT, Use Case Approach, Unified Approach, O-ET), design patterns, frameworks, and planning and managerial approaches on real software developments in various problem domains. The tutorial reports on both the good and the bad points of these techniques. The tutorial explains the aspects of various techniques that should be avoided and why they should be avoided. Five case studies (real) and the lessons that were learned from each are presented. They illustrate how to minimize software costs with OO and describe the common lessons that were learned while applying different object-oriented software techniques. Solutions and strategies relative to some existing problems with OO techniques will be presented. These lessons are related to: technical issues; modeling and notation issues; standards and process issues; design and testing issues, and transition and managerial issues. BACKGROUND: Participants should have a general familiarity with the object-oriented basic concepts and software engineering principles. This tutorial is intended for a broad community of computer and software professionals involved in the transition, management and development of object-oriented software projects. Software engineers, programmers, managers as well as system engineers, and application program developers will greatly benefit from the tutorial.
BIOGRAPHY: Mohamed Fayad is an Associate Professor at University of Nevada, Reno. He has been actively involved in over 60 OO projects in several companies using Shlaer-Mellor, Colbert, OMT, Use Case Approach, Unified Approach, Design Patterns, Frameworks, Distributed Computing, and others. Dr. Fayad is the guesteditor of three theme issues: CACM's OO Experiences, Oct. 95, IEEE Computer's Managing OO Software Development Projects, Sept. 96 and CACM's Design Patterns, Oct. 96. He has given tutorials and seminars on OO software engineering methods and Experiences at the 1991, 1992, and 1993 IEEE/AIAA Digital Avionics Systems Conference, the 1991 Computing in Aerospace Conference, TRI-Ada '92 and 1993, ACM Computer Science Conference, ECOOP '93, TOOLS USA '93, TRI-Ada '93, OO EXPO BOSTON '93, ECOOP '94, 1st Hong Kong Conference on Quality Software Development '96, Portugal, OOP '96, TOOLS USA '96, and TRI-Ada '96. He is invited this summer to present seminars and workshops in several countries: Hong Kong (2 visits, 12 presentations), Canada (3, 3), Portugal (1, 4), Egypt (1, 9), Saudia Arabia (1, 4), United Arab Emirates (1, 2), and Singapore (1, 2). Dr. Fayad is the sole author of OO Experiences, IEEE Computer Society Press, June 96, Software Development Planning for OO Projects, IEEE CS Press, April 96
RELATED TUTORIALS: Tutorial 48 User-Driven Strategies for Object-Oriented Development discusses related implementation issues.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM Wednesday PM
SPEAKER(S)/AFFILIATION: Grady Booch, Rational Software Corporation Ivar Jacobson, Rational Software Corporation Jim Rumbaugh, Rational Software Corporation , Gunaar Overgaard
ABSTRACT: The Unified Modeling Language (UML) represents the unification of the Booch, Objectory and OMT methods, with the inclusion of important concepts from a number of other methods. This tutorial will cover the UML in breadth and in some depth. We will take a use-case based approach, by examining a number of common modeling problems and their solution in UML. Attendees will leave with sufficient information to begin to apply UML to their projects.
BACKGROUND: Participants should have a basic familiarity with object-oriented concepts.
BIOGRAPHY: Grady Booch is Chief Scientist at Rational. He has been with the company since its foundation in 1980. Booch has pioneered the development of object-oriented analysis and design methods. His work centers primarily around complex software systems. Booch is the author of four books, including "Object-Oriented Analysis and Design," and "Object Solutions: Managing the Object-Oriented Project." He is a member of AAAS, IEEE, and CPSR, and is both an ACM Fellow and Rational Fellow.
Dr. James Rumbaugh is a Fellow at Rational Software Corporation. He has been active in object-oriented technology for many years and has spoken widely on it around the world. He is principal developer of the OMT method as well as developer of an object-oriented language and programming productivity tools. He worked for many years at the GE R&D Center, where he developed a wide variety of systems. He is principal author of "Object-Oriented Modeling and Design" as well as a regular columnist with Journal of Object-Oriented Programming.
Ivar Jacobson is inventor of the Objectory OO method, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community. 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 standard CCITT/SDL. 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.
RELATED TUTORIALS: Tutorial 52
The Semantics of the Unified Modeling Language focuses on the semantics
of the modeling language presented in this tutorial. Tutorial, 46
Applying the Unified Modeling Language, discusses the application of
this modeling language.
Other analysis and design methods tutorials:
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
40 Object Models:
Strategies, Patterns, and Applications
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition 44 Responsibility-Driven
Design
54 Real-Time Object-Oriented
Modeling
This tutorial will be repeated on Wednesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Alistair Cockburn, Humans and Technology
ABSTRACT: Enough OO projects have succeeded and failed that some patterns have emerged. This tutorial goes over some success and failure stories that shed light on the lessons to be learned, and then goes back to review, in sequence, steps that can be taken to reduce a project's risk. These start from reasons for selecting (or rejecting!) object technology in the first place, then selecting the project, the project's goals, the team, the education, and the tools. A second round of lessons cover typical issues that arise in the first, second and third increments of a system's delivery, and ways to tune the organization between increments. The third round raises the issue of trying to train large numbers of developers and questions of volume scaling. At the end, expectations, benefits and costs in the technology are reexamined in the light of the preceding discussion.
BACKGROUND: This tutorial is for managers and team leaders considering carrying out either a first, or a later, larger project in object technology. No knowledge of OO is required beyond what a cursory brush with the technology would provide. Deep technical knowledge will not interfere with the course contents. The attendee is expected to have a decided interest in the decision factors that drive the project, the project team, and the organization's growth.
BIOGRAPHY: Alistair Cockburn spent 4 years interviewing and reviewing projects to determine success and failure criteria, management and methodology issues, for those using and those only considering object technology. He was the focal point for object orientation for the IBM Consulting Group for 3 years, and author of its OO methodology, before founding Humans and Technology in Salt Lake City. The material for this tutorial are being collected for a book, "Surviving Your First Object Technology Project". He wrote "The Impact of Object-Orientation on Application Development" for the IBM Systems Journal and "In Search of Methodology" in Object Magazine, as well as numerous technical articles on software development. He currently leads and advises large OO development efforts.
RELATED TUTORIALS: Tutorial 51 The Manager's Role in a Successful Transition to Object-Orientation discusses related management issues.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Thomas J. Mowbray, Ph.D., The MITRE Corporation Raphael Malveau, MITREtek Systems
ABSTRACT: The Object Management Group's Common Object Request Broker Architecture (CORBA) specification has important implications to developers of Object-Oriented Systems. CORBA extends the benefits of object-orientation across distributed heterogeneous environments, including multiple languages and multiple operating systems. Additionally, the CORBA 2.0 specification standardizes interoperability between machines running different Object Request Brokers (ORBs). This tutorial will provide participants with information from software architects and developers who have experience implementing systems on a variety of CORBA-based products. Each segment of the tutorial focuses on key aspects of CORBA and related distributed object standards and technologies.
BACKGROUND: The level of this tutorial is introductory; there are no prerequisites.
BIOGRAPHY: Thomas J. Mowbray, PhD is a Principal Scientist in the Open Systems Center at The MITRE Corporation. He is the architect of DISCUS, the U.S. government's first CORBA-based OO architecture project. He has experience applying CORBA to multiple application domains, and has programmed applications on several ORB products. Dr. Mowbray is also the Chairman of the OMG's CORBAfacilities Task Force. Previously, Dr. Mowbray was a Principal Investigator at the Martin Marietta Corporation in Littleton, Colorado where he performed research in open systems prototyping and heterogeneous system integration. Dr. Mowbray is author of the book The Essential CORBA and is Architectures Columnist for OBJECT Magazine.
Raphael Malveau is a Member of Technical Staff of MITREtek Systems. He is the lead developer and architect of the DISCUS/CONCORD frameworks on the DEC ObjectBroker product suite. He has designed and implemented several CORBA frameworks and specializes in integrating CORBA with other technologies. He has designed and taught CORBA-based software architecture courses and consults to government organizations on system architecture, software design and CORBA implementations. He is MITREtek's lead researcher in Design Patterns, and is authoring a new book for John Wiley & Sons on CORBA Design Patterns.
RELATED TUTORIALS: Tutorials 9 Introduction to Distributed Computing Using Objects, and 50 Object Oriented Design Patterns for Concurrent, Parallel, and Distributed Systems, also discuss issues related to distribution of objects.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM Wednesday PM
SPEAKER(S)/AFFILIATION: Peter Coad, Object International, Inc.
ABSTRACT: This tutorial presents practical insights into building better object models. Participants will get specific strategies and patterns for building object models (applicable with whatever notation one prefers, including Coad, Booch, OMT, or Unified). These strategies and patterns are nuggets of wisdom, repeatable how-to advice, for building object models. The tutorial includes a hypertext handbook (177 strategies and 31 patterns, available from a web site), accelerating your ability to build better object models.
Strategies: specific, how-to wisdom for building effective object models
o Identifying purpose and features o Selecting objects o Establishing responsibilities o Working out dynamics with scenarios
Patterns: templates of objects with stereotypical responsibilities and interactions
o Transaction patterns o Aggregate patterns
BACKGROUND: Participants are expected to already be familiar with one or more OOA/OOD methods.
BIOGRAPHY: Peter Coad (pronounced "code") is the developer of the Coad method, a widely-practiced, comprehensive approach to software development. Peter is a multi-domain practitioner; he's built hundreds of object models. In addition, Peter is well-known for his lively, engaging, and highly effective "hands on" workshops; he is recognized as a master of teaching by example. Also, as President of Object International, Inc. (Raleigh NC USA), Peter leads his team in education, tools, and consulting for clients worldwide. His newest books are "Object Models: Strategies, Patterns, and Applications" and "Designing Better Apps and Applets with Java."
RELATED TUTORIALS: Tutorial 28 Design Patterns with Catalysis: Rigorous Modeling and Composition discusses related object-oriented design topics.
This tutorial will be repeated on Wednesday.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Adele Goldberg Kenneth S. Rubin, IBM North American Object Technology Practice
ABSTRACT: This tutorial is based on the work described in the presenters' book "Succeeding with Objects: Decision Frameworks for Project Management." The decision frameworks from this book suggest an approach for how to restructure an information technology organization to be effective users of object technology. This approach is based on four organizing themes: identifying desired goals, selecting development processes and resources that support these goals, improving staff skills to better use these processes and resources, and measuring progress towards attaining the goals.
A case study will be used to illustrate how the decision frameworks can be applied. This study introduces the idea that an important future business model is one of mass customization--giving customers exactly what they want, in any variety and volume, at mass production prices. Unfortunately, most information technology (IT) organizations are not prepared to provide services in a way that supports such a model. The study argues that IT organizations that restructure themselves to be effective users of object technology will find it natural to support a mass customization business model.
BACKGROUND: The tutorial is targeted to those individuals interested in the managerial issues that influence the successful adoption of object-oriented technology. It is assumed that the audience has some familiarity with the basic concepts of object technology and have begun to worry about how to effectively deploy the technology.
BIOGRAPHY: Dr. Adele Goldberg is the former Chairman of the Board and a founder of ParcPlace-Digitalk, Inc. Prior to the creation of ParcPlace, Adele received a Ph.D. in Information Science from the University of Chicago and spent 14 years as researcher and laboratory manager of Xerox Palo Alto Research Center. From 1984-1986, Adele served as president of the ACM, the computer professional society. Solely and with others, Adele wrote the definitive books on the Smalltalk-80 system and has authored numerous papers on project management and analysis methodology using object-oriented technology. Dr. Goldberg edited "The History of Personal Workstations," published jointly by the ACM and Addison-Wesley in 1988 as part of the ACM Press Book Series of the History of Computing which she organized, and co-edited "Visual Object-Oriented Programming" with Margaret Burnett and Ted Lewis. In 1995, a new book on software engineering appeared entitled "Succeeding With Objects: Decision Frameworks for Project Management" with Kenneth S. Rubin. She was recipient of the ACM Systems Software Award in 1987 along with Dan Ingalls and Alan Kay, PC Magazine's 1990 Lifetime Achievement Award for her significant contributions to the personal computer industry, is a Fellow of the ACM, and was honored in 1995 with the Reed College Howard Vollum Award for contributions to science and technology.
Kenneth Rubin is a Director and Managing Principal in the IBM North American Object Technology Practice where his focus is on new business development. Mr. Rubin is responsible for the creation and delivery of object technology services such as Object Transition Management and Business Object Modeling. In addition, Mr. Rubin is in charge of methodology deployment for object technology in North America, and directs the Object Technology Practice's business in the Petroleum industry. Mr. Rubin has over eleven years experience working on and managing software development project using object-oriented technology. He is the co-author, along with Adele Goldberg, of the book Succeeding with Objects: Decision Frameworks for Project Management, and the author of over 30 publications on the topics of managing object-oriented projects, object-oriented analysis and design, artificial intelligence and human-computer interaction. Over the past six years, he has presented tutorials, workshops and papers at over 100 conferences and companies in Australia, Canada, Europe, Japan, South America and the United States. Mr. Rubin is a member of the Editorial Board of Object Magazine. He received his BS. in Computer Science from the Georgia Institute of Technology and his MS. in Computer Science from Stanford University.
RELATED TUTORIALS: Tutorials 13 The Roles, Activities, and Organization of an Object Technology Center and 51 The Manager's Role in a Successful Transition to Object-Orientation discuss other management topics.
Back to OOPSLA '96 Tutorial Overview
Monday 8:30AM - 12PM
SPEAKER(S)/AFFILIATION: Gregor Kiczales, Xerox PARC Chris Maeda, Xerox PARC
ABSTRACT: How does one design high-performance reusable code? It has to please a wide range of clients--so it will be reused--and yet it must provide all of them with good performance. This kind of problem, once the sole responsibility of system software experts, is of increasing importance to the designers of any code that is intended to be reusable.
This tutorial will present case studies--small and large, new and old--that are examples of high performance, reusable software. From these examples, we will abstract a set of guidelines and techniques that can be used to understand the examples, and that can be applied to your future design problems.
BACKGROUND: General familiarity with computer science. Experience designing or using reusable software is a plus. This tutorial will be of particular interest to anyone setting out to design or re-design reusable middleware or class libraries.
BIOGRAPHY: Gregor Kiczales is a principal scientist at the Xerox Palo Alto Research Center. He is one of the inventors of the concept of open implementation which is at the foundation of this tutorial.
Chris Maeda is a researcher at Xerox PARC. He has experience applying these techniques to a wide variety of software systems from operating systems to applications.
RELATED TUTORIALS: Tutorial 47 Efficient Implementation of Object-Oriented Programming Languages also explores the impact of performance on object-oriented development.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM Thursday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Jan Christiaan van Winkel, AT Computing Marian Hellema, AT Computing
ABSTRACT: The C++ language lacked a standard library so far. Of course the iostream library has been there from the beginning, but an object oriented equivalent of the standard C library has now been introduced in the ANSI/ISO draft C++ standard. Some of the features of the new standard C++ 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. 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.
BACKGROUND: The attendees should know the C++ syntax. Experience with C++ programming is strongly recommended.
BIOGRAPHY: JC van Winkel has a BS and a MS in computer science (the MS from the Vrije Universiteit Amsterdam). After working as a programmer/consultant for KPMG EDP Auditors for 6 years, he started at AT Computing in 1990. There he teaches UNIX and UNIX-related subjects, including C and C++. He co-authored the course notes for the C++ course with a colleague. These course notes were published as a book by the Dutch publisher ``academic service''. J.C. van Winkel presented iostreams tutorials at OOPSLA93 and OOPSLA94.
Marian Hellema develops and gives courses in C, C++ and UNIX since four years. 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 during a year.
RELATED TUTORIALS: Tutorial 33 Smalltalk as a Second Language is also geared for C++ programmers. Tutorial 30 Designing High-Performance Reusable Code discusses other object-oriented development issues.
This tutorial will be repeated on Thursday afternoon.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM Thursday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Rebecca Wirfs-Brock, Parcplace-Digitalk Alan McKean, Parcplace-Digitalk
ABSTRACT: Many of the stakeholders in our design efforts do not speak in our native object-oriented tongue. In our role of object designer we face three challenges: correctly interpreting stakeholders' concerns and requirements , synthesizing those requirements in our models, and presenting our design work in terms they can understand. We present an idealized design process for describing our software from an external perspective and then evolving these descriptions into a working application. Our process can be broken down into these phases: System Description, Exploratory Design, and Design Refinement.
This tutorial will o overview our current event-oriented analysis and responsibility-driven design process o describe the activities and artifacts of each phase o architect the system through an event-driven analysis of business processes o present guidelines and examples to illustrate key decisions and work products o conclude with a case study
Since interactions with the environment, execution control style, richness of communications, object role stereotypes, and object collaboration patterns have significant impacts on the design, we focus on these aspects in our tutorial and discuss how best to distribute responsibilities among potentially distributed collaborating objects. We also will emphasize refinement and reuse design activities, contrast inheritance and configurable algorithms with composition techniques, structure use cases to incorporate goals and actor/system conversations, and discuss several strategies that can be used to increase a design's flexibility: loosely coupling objects with events, designing abstract patterns of messaging with contracts, and dynamically configuring object behaviors with composition.
BACKGROUND: Familarity with 0bject-oriented concepts
BIOGRAPHY: Rebecca Wirfs-Brock is Director of Applied Object Technology at ParcPlace-Digitalk. Rebecca is responsible for defining and shaping the design and development practices and methods for ParcPlace-Digitalk consultants and their clients. She is a recognized author, teacher and speaker on object design and co-inventor of the Responsibility-Driven design method. Rebecca was the lead author of Designing Object-Oriented Software, Prentice-Hall, 1990. Most recently, she served as conference chair of OOPSLA 95.
Alan McKean is the curriculum architect at Parcplace-Digitalk. He has been involved with design techniques since 1973, while studying with R. Buckminster Fuller's Design Department at Southern Illinois University. He began working with object-oriented languages and techniques in 1984, specializing in modeling and simulation while completing his M.S. in Computer and Information Science at the University of Oregon. Attracted to Parcplace-Digitalk in 1992 by the work of Rebecca Wirfs-Brock, he has been an important contributor to the method and the instructional techniques for presenting it. Most recently, he was a keynote speaker at the OOPSLA '95 Educators' Symposium and has been developing a curriculum for teaching distributed object systems.
RELATED TUTORIALS: Other analysis and design methods tutorials:
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
37 The Unified Modeling Language
40 Application
of Object-Oriented Technology in Real-Time Embedded Systems
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
42 The Semantics
of The Unified Modeling Language
46 Applying
the Unified Modeling Language
54 Real-Time Object-Oriented
Modeling
This tutorial will be repeated on Tuesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM Wednesday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Martin Fowler, Independent Consultant
ABSTRACT: Anyone entering OO analysis and design is faced with a plethora of textbooks and methods. This tutorial looks at the fundamental concepts of OO analysis and design and how these are reflected in various OO methods. A simple framework is used to help compare the methods and understand their similarities and differences. This helps the attendee follow the presented methods, together with other methods that the attendee may come across.
In general, each method is made up of several techniques (e.g. ER modelling, state transition diagrams) each of which emphasises a particular aspect of the system and neglects others. The tutorial shows the techniques each method uses and how different methods use different dialects of the same techniques, varying the notation and introducing new concepts. In this way methods can be compared on how they treat the basic concepts and how these are used in the analysis and design process.
BACKGROUND: Attendees should have a working knowledge of at least one OO or structured analysis and design method, and an understanding of basic OO principles.
BIOGRAPHY: Martin Fowler is an independent consultant who has pioneered the use of Object Oriented analysis and design for corporate information systems. These include a clinical health care model for the UK National Health Service, a derivatives trading system for a major London bank, and a centralized payroll system for Chrysler. Currently he is training and mentoring commercial development projects in Europe and North America, and developing the field of analysis patterns.
RELATED TUTORIALS: Tutorials 1
Concepts of Object-Oriented Programming and 39
Introduction to CORBA are also introductory tutorials.
Tutorials discuss analysis and design methods:
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
44 Responsibility-Driven
Design
37 The Unified Modeling Language
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
This tutorial will be repeated on Wednesday afternoon.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Craig Larman, ObjectSpace, Inc.
ABSTRACT: The Unified Modeling Language (UML) represents an emerging standard notation for object-oriented analysis and design artifacts, such as class diagrams. It is meant to consolidate and eventually replace the prior notations of its creators: OMT by James Rumbaugh and Booch by Grady Booch. This tutorial provides an intensive learning environment in which to practice the application of the UML. Based on adult learning principles, this is a lively hands-on session in which participants work in small groups to create the major artifacts: use cases, class diagrams, object message diagrams, and so on. A cohesive understanding of the method is achieved by its application to a realistic information system problem. While creating message diagrams, participants will strengthen their design skills by learning and applying the GRASP design 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 familiarity with at least one other object-oriented analysis and design method, such as OMT or Booch. In particular, participants should have experience creating several class (or object) models and message diagrams in some method. Time will not be spent defining or motivating artifacts, but on showing their notation and semantics with the assumption that participants are familiar with common analysis and design documents.
BIOGRAPHY: Craig Larman has been using object technology since 1984 when he started developing knowledge systems on LISP machines. He is active in teaching and mentoring developers in the use of UML, having taught several hundred participants in five-day courses. In addition, he is writing a book for Prentice-Hall on the UML and ANSI Smalltalk. 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 Smalltalk, C++ and object-oriented analysis and design. To date, he has personally taught object technology skills to over one thousand students. Currently, he is a senior object technology instructor with ObjectSpace, Inc. Craig holds a B.Sc. and M.Sc. in computing science.
RELATED TUTORIALS: Tutorial 37
The Unified Modeling Language gives an overview of the modeling
language presented in this tutorial.
Other analysis and design method tutorials:
6 Shlaer-Mellor
Recursive Design Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
40 Object Models:
Strategies, Patterns, and Applications
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
44 Responsibility-Driven
Design
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Craig Chambers, University of Washington
ABSTRACT: 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 aims to answer these questions. The tutorial will begin by presenting the important language design issues, identifying the features of object-oriented languages that are difficult to implement efficiently. In the main part of the tutorial, three classes of implementation techniques will be presented. First, run-time system techniques such as virtual function dispatch tables (including complications due to multiple inheritance and virtual inheritance) and inline caches will be described. Second, the tutorial will describe several levels of static analyses which seek to identify at compile-time the possible classes of message receivers in order to reduce or eliminate the overhead of dynamic binding. Third, the tutorial will discuss ways in which dynamic execution profiles can be exploited to complement static analysis techniques. The tutorial will present empirical measurements of the effectiveness of these various techniques for different kinds of programs and languages.
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.
BIOGRAPHY: Craig Chambers has been researching object-oriented language design and implementation since 1987, with publications in OOPSLA, ECOOP, ISOTAS, PLDI, PEPM, and TOPLAS on the topic. He developed the first efficient implementation of the Self language, and he is the designer of the Cecil language and heads the Vortex optimizing compiler project. Chambers is currently an Assistant Professor of Computer Science & Engineering at the University of Washington.
RELATED TUTORIALS: Tutorial 42 Designing High-Performance Reusable Code also explores the impact of performance on object-oriented development.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Sanjiv Gossain, Cambridge Technology Bernard Horan, Consultant
ABSTRACT: It is a well-known feature of object-oriented development that designers and end-users gain from the perceived tangibility of object-oriented models. Similarly, there is evidence of the benefits to be gained by involving users in the development process. However, object-oriented methods tend to ignore users' needs during system development--they are more concerned with object modelling than with the need to provide a framework in which users can contribute to the development process.
This tutorial redresses the balance by describing user-driven object strategies that acknowledge the users' contribution to the development process. Based on the presenters' experience, the tutorial provides examples of how to work with users, and how to provide a more user-focused environment that values the co-operation between users and designers. Practical techniques are identified to show how to maximise the effect of users in building modern client/server systems.
BACKGROUND: Participants should have a general familiarity with object-oriented concepts and the object-oriented lifecycle. No fluency in any object-oriented language is required. The intended audience is practising object-oriented analysts/developers with a keen interest in improving their working practice.
BIOGRAPHY: Sanjiv Gossain is an Technology Director (Europe) of Cambridge Technology Partners. He is a regular contributor to object-oriented magazines and has spoken at numerous conferences. Sanjiv has been involved in object technology for nine years, and holds a PhD in "Object Oriented Development and Reuse".
Bernard Horan is a freelance consultant. He has given papers and tutorials at several conferences and is a columnist for "Object Expert". Bernard has been teaching object-oriented technology and user-centred design for the past four years.
RELATED TUTORIALS: Tutorial 14 Techniques for Systematic Design of Graphical User Interfaces (for Highly Usable Systems) based on Use Cases, also discusses issues related to user-interaction. Tutorial 36 Object-Oriented Experiences and Future Trends, discusses related implementation issues.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Martin Abadi, Digital Luca Cardelli, Digital
ABSTRACT: This tutorial introduces a theory of objects as a foundation for object-oriented languages and programming. This theory provides explanations for object-oriented notions in terms of a few basic primitives and can be useful for the design and understanding of programming languages.
We cover both the semantics of objects and their typing rules. We account for a range of object-oriented concepts, such as self, dynamic dispatch, classes, inheritance, prototyping, subtyping, covariance and contravariance, and method specialization.
PREREQUISITES: The intended audience of the tutorial consists of computer scientists, professionals, and students with an interest in modern language issues. The desired background is: o familiarity with more than one OO language o some understanding of standard run-time behavior of OO languages o some understanding of standard typing issues for OO languages o some previous exposure to formal systems (for example, operational semantics, typing rules) o ability to follow simple mathematical arguments.
BIOGRAPHY: Martin Abadi's research interests are in three areas: security in distributed systems; specification and verification methods; programming languages, in particular principles of object-oriented programming.
Luca Cardelli's main interests are in type theory and operational semantics, mostly for applications to language design, semantics, and implementation. He implemented the first compiler for ML and one of the earliest direct-manipulation user-interface editors. He was a member of the Modula-3 design committee, and has designed a few experimental languages, of which the latest is Obliq: a distributed higher-order scripting language. His more protracted, as well as more recent, research activity has been in establishing the semantic and type-theoretic foundations of object-oriented languages.
RELATED TUTORIALS: Tutorials 10 Types for the Language Designer, and 21 Typing in Object-Oriented Languages: Achieving Expressiveness and Safety, also discuss language typing issues.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Douglas C. Schmidt, Washington University
ABSTRACT: Developing extensible communication software that effectively utilizes concurrency on multi-processor platforms attached to high-speed networks is a complex task. This tutorial examines and evaluates a suite of object-oriented design patterns that help to alleviate the complexity of developing concurrent, parallel, and distributed object-oriented software. These patterns (and the framework components that implement them) have been used successfully on major OO communication software projects for Ericsson, Motorola, Siemens, and Kodak to build telecommunication switch management applications, network management for large-scale global personal communication systems, and electronic medical imaging systems.
The tutorial illustrates by example how to significantly simplify and enhance the development of software that effectively utilizes concurrency and network services via the use of:
Object-oriented design techniques -- such as design patterns, layered modularity, and information hiding
Object-oriented language features -- such as abstract classes, inheritance, dynamic binding, and parameterized types
Tools -- such as object-oriented communication frameworks and object request brokers (ORBs) like OMG CORBA and Network OLE
Advanced operating system mechanisms -- such as event demultiplexing, multi-threading, multi-processing, and explicit dynamic linking
The tutorial examines patterns and C++ code abstracted from production distributed electronic medical imaging and telecommunication systems to illustrate key points in the examples.
BACKGROUND: The tutorial is intended for software developers who are familiar with general object-oriented 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).
BIOGRAPHY: Dr. Schmidt is an Assistant Professor of Computer Science at Washington University in St. Louis, Missouri, USA. His research focuses on design patterns, implementation, and experimental analysis of object-oriented techniques for developing high-performance distributed communication systems on parallel processing platforms that run over high-speed networks. Dr. Schmidt has published widely in IEEE, IFIP, ACM, and USENIX technical conferences and journals on communication software systems, parallel processing for high-performance networking protocols, distributed object computing, and object-oriented design patterns and programming. He is the program chair for the 1996 USENIX Conference on Object-Oriented Technologies and Systems (COOTS) and the 1996 Pattern Languages of Programming conference. Dr. Schmidt is a co-editor on a book entitled ``Pattern Languages of Program Design'' with Jim Coplien of AT&T Bell Labs. Dr. Schmidt is writing a book for Addison-Wesley with Steve Vinoski on object-oriented network programming for a series edited by Brian Kernighan.
RELATED TUTORIALS: Tutorials 9 Introduction to Distributed Computing Using Objects, 35 OLE, CORBA - Infrastructures for Distributed Object Computing, and 39 Introduction to CORBA also discuss issues related to distribution of objects. Tutorial 3 An Introduction to Design Patterns, gives an overview of design patterns.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM Thursday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Norm Kerth, Elite Systems
ABSTRACT: 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.
This highly acclaimed tutorial discusses what managers should expect and need to do as their organization grows in its maturity to use objects. It is a course loaded with a great deal of wisdom and experience.
To realize these benefits and avoid the pit falls it is not good enough to simply let a few engineers use an object-oriented language. There is a great deal that needs to be managed, controlled and nurtured. In this tutorial, you learn how to develop a program that allows you to manage the introduction of this new technology into your projects.
BACKGROUND: None.
BIOGRAPHY: Norm Kerth is a consultant working with companies interested in ensuring that they make a successful transition to using the object-oriented technologies. Prior to starting his company, Elite Systems, he was a professor and researcher at the University of Portland. He has a decade of engineering experience with Tektronix and is a master teacher, with over 25 years of experience in front of students and computer professionals. He has been a frequent participant at OOPSLA since 1987.
RELATED TUTORIALS: Tutorials 38, "Surviving Your OO Project," and 31, "Managing for Effective Use of Object Technology," discuss related management issues.
This tutorial will be repeated on Thursday afternoon.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Gunnar Overgaard, Royal Institute of Technology/Rational Software Corporation Grady Booch, Rational Software Corporation Ivar Jacobson, Rational Software Corporation Jim Rumbaugh, Rational Software Corporation
ABSTRACT: The Unified Modeling Language (UML) is a newly developed modeling language which has emerged from the Booch method, Objectory and OMT. Different presentations have been given of the Unified Modeling Language, e.g. at OOPSLA'95, but this is the first in-depth tutorial on the semantics of the language. The tutorial will focus on the semantics of the language. Interesting language constructs will be presented in terms of its abstract syntax, semantics and pragmatics. The concrete notation will of course also be presented. The tutorial will also discuss how to adjust the semantics of UML to the different needs of different kinds of systems, projects and users.
BACKGROUND: Background assumed by the tutorial: Participants should be know the basics of object-oriented modeling languages, such as the Booch method, Objectory, and OMT. Knowledge of operational semantics will be useful, but is not required. The tutorial is aimed at software developers and persons in charge of methods who wish to get a more thorough and precise knowledge of the Unified Modeling Language.
BIOGRAPHY: Gunnar Overgaard has worked at Rational (formerly Objectory AB) as a member of the process business unit. Being one of the first to join Objectory AB, he has been involved in several different activities, including customer projects, process and method development, specifying the requirements on the Objectory CASE tool and extensive teaching. He is a co-author of the Addison-Wesley bestseller "Object-Oriented Software Engineering - A Use Case-driven Approach". Gunnar has worked with method development for some 10 years, including Objectory and UML, and has written the formal specification of UML.
Grady Booch is Chief Scientist at Rational. He has been with the company since its foundation in 1980. Booch has pioneered the development of object-oriented analysis and design methods. His work centers primarily around complex software systems. Booch is the author of four books, including "Object-Oriented Analysis and Design," and "Object Solutions: Managing the Object-Oriented Project." He is a member of AAAS, IEEE, and CPSR, and is both an ACM Fellow and Rational Fellow.
Dr. James Rumbaugh is a Fellow at Rational Software Corporation. He has been active in object-oriented technology for many years and has spoken widely on it around the world. He is principal developer of the OMT method as well as developer of an object-oriented language and programming productivity tools. He worked for many years at the GE R&D Center, where he developed a wide variety of systems. He is principal author of "Object-Oriented Modeling and Design" as well as a regular columnist with Journal of Object-Oriented Programming.
Ivar Jacobson is inventor of the Objectory OO method, and founder of Objectory AB, Sweden. He is currently VP of Business Engineering at Rational Software Corporation. He is a leader in the OO community. 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 standard CCITT/SDL. 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.
RELATED TUTORIALS: Tutorial 37
The Unified Modeling Language gives an overview of the modeling
language presented in this tutorial.
6 Shlaer-Mellor
Recursive Design: Designing Model Compilers
25 Working
with Objects: Use and Reuse with Role Model Analysis and Synthesis
40 Object Models:
Strategies, Patterns, and Systems
28 Design Patterns
with Catalysis: Rigorous Modeling and Composition
44 Responsibility-Driven
Design
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: James C. McKim Jr., Hartford Graduate Center Richard S. Wiener, University of Colorado at Colorado Springs
ABSTRACT: Programming by contract (PBC) is a form of object oriented programming popularized by Bertrand Meyer in his book, Object Oriented Software Construction. In PBC, forms of assertions called preconditions, postconditions, and invariants are used to help programmers and designers reason about their software artifacts. The ideas embodied in PBC are simple, but quite powerful, and, when properly applied, result in simpler and shorter code than would otherwise be the case. PBC is flexible enough to be of great assistance in the specification, documentation, and verification of features and classes.
This Tutorial presents a series of principles that working software professionals can apply today to rigorously specify their class designs and hence reap the benefits of better documentation and easier verification. Examples will be given in both Eiffel and C++.
BACKGROUND: The ideal audience member should have a good grasp of the major features of the object oriented paradigm, including encapsulation, inheritance, and polymorphism. It is also essential that the attendee have good knowledge of programming by contract at the level of Object Oriented Software Construction [1] or ``Applying Design by Contract" [2]. Attendance of a previous Tutorial on this subject is sufficient. Some background in either Eiffel or C++ would be helpful but is not required.
BIOGRAPHY: Dr. McKim has more than twenty years experience teaching mathematics and computer science. He has authored, coauthored and reviewed a number of textbooks and articles in both areas. He has been teaching, publishing, and consulting in the OO arena for the past six years and has given numerous tutorials at OO conferences, including three at past OOPSLA conferences. His research interests include object oriented programming and design in general, and class interface specification in particular.
Richard Wiener is the founding Editor-in-Chief of the Journal of Object-Oriented Programming and Report on Object Analysis and Design. He has authored or co-authored 19 books in different areas of computer science (with John Wiley, Addison-Wesley and Prentice-Hall), the most recent being "An Object-Oriented Introduction to Computer Science Using Eiffel" and "An Object-Oriented Introduction to Data Structures Using Eiffel". Dr. Wiener is a frequent speaker at conferences in the US and Europe. In 1983 he received the Teacher of the Year Award at the University of Colorado.
RELATED TUTORIALS: Tutorial 20 Advanced Object-Oriented Analysis discusses advanced topics in analysis and design.
Back to OOPSLA '96 Tutorial Overview
Monday 1:30PM - 5PM
SPEAKER(S)/AFFILIATION: Bran Selic, ObjecTime Limited
ABSTRACT: The intricacy of most real-time systems is simply a reflection of the bewildering complexity of the real-world. When we consider the additional challenges of meeting stringent timing and resource constraints it becomes evident that real-time software design cannot be adequately addressed through general-purpose development methods.
Real-Time Object-Oriented Modeling (ROOM) is a practical method for developing real-time software that combines the object paradigm with advanced domain-specific modeling concepts. Special emphasis is placed on modeling the architectural levels of software that are key to reliability, understandability, and evolvability. The method is also distinguished by its ability to take advantage of computer-based automation (through executable models, reuse, and automatic code generation) for better product quality and greater productivity. In the past several years, ROOM has been used successfully on a large number of diverse industrial projects.
The primary objective of the tutorial is to demonstrate how the object paradigm can be used to advantage to develop reliable real-time software.
BACKGROUND: Basic familiarity with real-time software and concurrent programming is assumed. Some prior exposure to the essential concepts of the object paradigm is advisable.
BIOGRAPHY: Bran Selic is the Vice President of Research & Technology at ObjecTime Limited, a company that develops and markets the ObjecTime toolset that supports the ROOM method. He has over 20 years of experience, both as a developer and a manager, with real-time software development, covering a spectrum of application domains (telecommunications, aerospace, and robotics), and over 9 years of experience with object-oriented design and programming. Mr. Selic is a member of the OOPSLA'96 Program Committees and is also a long-standing member of the program committee for the TOOLS USA conferences. He is the principal author of the book, "Real-Time Object-Oriented Modeling", co-authored with Garth Gullekson and Paul Ward.
RELATED TUTORIALS: Tutorial Application of Object-Oriented Technology in Real-Time Embedded Systems also discusses issues in object-oriented real-time systems. Tutorials 6 Shlaer-Mellor Recursive Design: Designing Model Compilers, 25 Working with Objects: Use and Reuse with Role Model Analysis and Synthesis, 37 The Unified Modeling Language, and 28 Design Patterns with Catalysis: Rigorous Modeling and Composition, describe other analysis and design methods.
Back to OOPSLA '96 Tutorial Overview
This information last updated by ayers@zti.com August 23,
1996
http://www.acm.org/sigplan/oopsla/oopsla96/tutorials-desc.html
Copyright 1996. All Rights Reserved
