From: johnson@m.cs.uiuc.edu (Ralph Johnson)
Newsgroups: comp.object
Subject: Re: OOPSLA '92 tutorials
Date: 14 Aug 92 18:46:04 GMT
Article-I.D.: m.1992Aug14.184604.31489
Organization: University of Illinois, Dept. of Comp. Sci., Urbana, IL

I've been told that the tutorials are not numbered in the description
that I posted, yet parts of the description refer to them by number.
It appears that the version of the description that I got does not
have the numbers, so this is not easy to fix.  I edited the posting
so that there is at least one place where tutorials are numbered,
and hopes that makes it easier to follow.  Here is the new version:
___________________

OOPSLA'92 Tutorials.

Please post this on local bulletin boards, especially in the Northwest
region close to Vancouver, and especially in big companies like Microsoft.
The tutorials are October 17 and 18 (in Vancouver, of course).  To get
an official registration form, send e-mail to mann@eola.cs.ucf.edu.

You can get a nicely formatted copy of this document in Rich Text Format 
by anonymous ftp from st.cs.uiuc.edu in /pub/oopsla.  There is also an
archive server that will send you copies by e-mail.  Send a message to
archive-server@st.cs.uiuc.edu of the form

path  your-id@your-host-id
send oopsla/Tutorials.rtf

Ralph E. Johnson -- University of Illinois at Urbana-Champaign
_____________________________ 

This year's tutorials cover a wide range of topics, and are designed
to appeal to practitioners, managers, and researchers. The tutorials
have been placed in three categories depending on the amount of
experience you require with object-oriented technology in order to
benefit from them.  The "beginning" tutorials assume no knowledge of
object-oriented programming, though tutorial 16 would be suitable for
someone with more experience since it focuses on management
techniques.  "Intermediate" tutorials assume some knowledge of
object-oriented techniques, and "advanced" assume several years
experience. Note that these categories describe your levels of
object-oriented knowledge. For example, tutorial 27 assumes an
advanced level of object-oriented experience, but does not assume that
you know much about visual programming languages.

 1 Concepts of Object-Oriented Programming	-- Full Day
 2 Object Design for Modularity, Reuse and Quality -- Full Day
 3 A Comparison of Object-Oriented Analysis and Design Methods -- Morning
 4 Integrating Analysis and Design Methods -- Afternoon
 5 Object-Oriented Concurrent Programming  -- Full Day
 6 Types for the Working Programmer  -- Morning
 7 Types for the Language Designer  -- Afternoon
 8 Simulation with DEVS-CLOS -- Morning
 9 Advanced CLOS and Meta-Object Protocols -- Afternoon
10 Introduction to Object-Oriented Database Management Systems -- Full Day
11 Object-Oriented Software Development with the Demeter Method -- Afternoon
12 Object-Oriented User interfaces  -- Morning
13 Evaluating Reusable Class Libraries  -- Afternoon
14 Object Engineering  -- Morning
15 Teaching Object-Oriented Programming and Design  -- Afternoon
16 Object-Oriented Project Management  -- Full Day
17 Introduction to Object-Oriented Design -- Morning
18 The Pragmatics of Building Object-Oriented Systems -- Afternoon
19 A Case Study of Domain Analysis: Health Care  -- Morning	
20 The Analysis and Design of Distributed Systems -- Afternoon
21 Specification Techniques for Object-Oriented Software -- Full Day
22 Writing Efficient C++ Programs -- Morning
23 The Design and Management of C++ Class Libraries -- Afternoon
24 Hardware Support for Object-Oriented Systems  -- Morning
25 Efficient Implementation of OOP Languages -- Afternoon
26 Constraint-Based Languages and Systems -- Morning
27 Visual Programming Languages from an Object-Oriented Perspective  -- Afternoon
28 Intermediate Smalltalk: Practical Design and Implementation -- Morning
29 Writing Efficient Smalltalk Programs -- Afternoon
30 Testing Object-Oriented Software -- Full Day
31 Object-Oriented Geometry and Graphics -- Morning
32 The Design of an Object-Oriented Operating System:  
   A Case Study of Choices  --    Afternoon
33 Teaching "Object-Think" with Multi-Sensory Engagement -- Morning
34 Schema Updates for Object-Oriented Database Systems -- Afternoon

Analysis and Design 

Tutorial 2 is a design tutorial suitable for those
who might have been using an object-oriented programming language,
but have never followed any particular design method. It covers all
areas of the design phase, with an emphasis on design for reuse. It is
also suitable for those who are moving into object-oriented technology
and prefer an explicit design phase, or those who want an
object-design method that emphasizes reuse.  Tutorial 17, which is a
quick survey of Booch's design method, is also suitable for those with
no experience with a formal design method. On the other hand, tutorial
18 assumes that you know Booch's design method.  Tutorials 3 and 4
both compare different design and analysis methods, so you should know
at least one method before you take them. They have different points
of view (3 is analytic and 4 is synthetic) so many methodologists will
want to take both.  Tutorials 20 and 21 are advanced tutorials that
focus on particular aspects of design and analysis. Tutorial 20
describes techniques to analyze and design distributed object-
oriented systems, while 21 surveys operational and descriptive
specifcation techniques for object-oriented software engineering.
You should only take them if you have a sufficient background in
design and analysis methods to be able to integrate these techniques
into whatever method you are currently using.  Tutorial 11 is a
fast-paced introduction to a formal design method that is backed by
tools that convert graphics into code. Tutorial 19 is a case study in
object-oriented domain analysis. The other case studies (8, 31 and 32)
might also be of interest to those studying design.

Languages 

Tutorials 22 and 23 focus on C++. Tutorial 14 focuses on
low-level design issues important for C++. Tutorial 32 is a case study
of a system written in C++. Most of the libraries used as examples in
tutorial 13 are in C++.  Tutorials 28 and 29 focus on Smalltalk.
Tutorial 31 is a case study of a system written in Smalltalk, and
tutorial 5 uses Smalltalk as a language for examples.  Tutorial 9 is
about the CLOS meta-object protocols, and is of interest both to CLOS
programmers and to language designers who want to see practical and
useful examples of reflective programming. Tutorial 8 is a case
study of a simulation system in CLOS, and can serve as an introduction
to CLOS for non-CLOS programmers wanting to take tutorial 9, though it
is primarily a case study, and is as much an introduction to
simulation as to CLOS.  Tutorials 6, 7, 24 and 25 will be interesting
to language designers and implementors, or to those who like to know
how their programming languages work, and why. We have tried to avoid
duplicating material in tutorials 6 and 7. Thus, 7 does not motivate
contravariance, and those interested in 7 who are not familiar with it
should be sure to take 6. Tutorial 5 covers concurrent languages, 27
visual languages, and 26 constraint languages.

Software Engineering

There is more to software engineering than analysis and design
methods. There are tutorials on managing the development of
object-oriented software (16), on testing (30), on reusable
libraries(13 and 23), on user interface design (12) and on low-level
object engineering (14). These tutorials are designed to appeal to
people with a wide range of expertise in objects, so don't be worried
if they are labeled "intermediate" and you consider yourself an
expert.

Education

There are two tutorials on how to teach what you've learned at OOPSLA.
Tutorial 15 is aimed at academics, who have a semester to teach, while
tutorial 33 is aimed at teachers in industry, who have only a short
time to enable their students to "get it" and who need quick,
effective teaching methods.

Databases

Tutorial 10 is an introduction to OODBMS, while 34, although it is an
intermediate tutorial, assumes some exposure to OODBMS, such as that
given by 10.

Graphics and User Interfaces

Tutorial 12 is entirely on user interfaces, and 31 is on both graphics
and user interfaces.  Constraint systems, the topic of tutorial 26,
are a common part of user interfaces, so that tutorial might be of
interest to user interface implementors. Tutorial 27 is an application
of graphics and user interfaces, though it is more closely related to
language design.

SUNDAY, OCTOBER 18


Concepts of Object-Oriented Programming

Sunday:	Full Day
Level:	Beginning
Raimund K. Ege, Florida International University

This tutorial defnes and teaches the basic concepts of object-oriented
programming, illustrates the advantages of object-oriented techniques
over conventional programming, introduces the components of an
object-oriented programming environment, and gives an overview of the
features of object-oriented languages and environments. This tutorial
will let you make an informed decision about what language/environment
will best serve your programming needs.

Raimund K. Ege is an associate professor of Computer Science at the
Florida International University, Miami. He is the author of
Programming in an Object-Oriented Environment (Academic Press, 1992).
His research interests include the application of object-oriented
concepts to programming, user interfaces, databases, simulation and
software engineering.  He has given many tutorials at OOPSLA, and is
rated very highly by his audiences.


Object Design for Modularity, Reuse and Quality
Sunday:	Full Day
Level:	Intermediate
Douglas Bennett, Design Ways 

Turning buzzwords like modularity, reusable components, extensibility,
testability, and robustness into reality requires more than just a
compiler for an object-oriented language, or even an integrated
development environment. These properties must be "designed into" the
software product. This tutorial shows how to make design decisions so
the product will do what its users want and so the buzzwords actually
show up in the product. The tutorial will work through the steps of a
design project, documenting user and producer needs, modeling the
"thing" objects, describing behavior with event response models, and,
fnally, developing an architecture for the product. Part of each step
is evaluating the design against the magic words. The result will be a
product structure that is probably very different from conventional
software architectures, but one that can be measured against the
design criteria.

This tutorial teaches the explicit design of software. It uses
notations from several existing methods. You may use your own
notations, if you wish.

Doug Bennett is a chemical engineer who moved into software 10 years
ago. He believed the hype about a "better way to build software" and
taught object technology for Stepstone.  When he learned that the
"better way" did not come with the compiler, he returned to his
engineering design roots and founded Design Ways. His training and
consulting clients have included Bellcore, Bank of New York, Timeplex,
Contel IPC, and Dun & Bradstreet Software.  He has used the design
techniques in this tutorial on a telephone switch, a T1 network,
accounting systems, and a bank position limit monitor system.

A Comparison of Object-Oriented Analysis and Design Methods
Sunday:	Half Day-Morning
Level:	Advanced
Martin Fowler

This tutorial shows how to look inside design and analysis methods to
see how they differ, and more importantly, how they are the same. It
examines several of the most well-known methods, including Booch,
Coad/Yourdon, Odell/Martin, Rumbaugh, and Schlaer/Mellor, but its
analysis techniques can be applied to any method.

In general, each method is made up of several techniques (e.g. ER
modeling, state transition diagrams) each of which emphasizes a
particular aspect of the system. These techniques can be classifed as
being for structural (data), behavioral or architectural modeling. 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. It uses examples to show how
the same system is expressed in different ways by the various methods.
The tutorial also compares the design approach advocated by each
method.

This tutorial will help you decide which method will work best for
you. In addition, you will learn how ideas from different methods can
be combined to better suit the system under analysis.
	
Martin Fowler is an analyst and designer with previous experience with
Coopers & Lybrand UK and with ADT. For the last three years he has
been employed by the UK National Health Service to produce a generic
model for health care, which is the subject of tutorial 13. He also
teaches and consults on object-oriented analysis and design.


Integrating Analysis and Design Methods

Sunday:	Half Day-Afternoon
Level:	Advanced
Paul Jeremaes & Patrick Arnold, HP Labs, England

Most of those who practice object-oriented analysis and design do not
follow any standard method exactly, but combine different techniques
to suit their own unique requirements. Each method employs its own set
of models, notations, and processes, so it can be difficult to combine
them. This tutorial shows how to design a method by providing a
framework for understanding and evaluating current methods, applying
it to three recent methods (OMT (Rumbaugh et al), Responsibility
Driven Design/CRC cards, Booch 91 Method), and combining them to
produce a new method, FUSION, that builds on their best aspects.

The tutorial introduces a set of criteria for evaluating methods from
the viewpoint of the object-oriented concepts they support, the kinds
of models and notations they employ and the process steps that they
recommend. The criteria provides a way to understand the underlying
similarities and differences between methods.

The criteria were developed as part of a program to assess what kind
of method should be made available to HP engineers, which led to the
development of the FUSION method. The tutorial ends with a brief
account of the usefulness of FUSION in practice.

Derek Coleman is a Project Manager at HP Laboratories leading a
research and consulting team working on object-oriented methods. Derek
is an active member of the object-oriented research community and the
author of many papers on software engineering.

Patrick Arnold has worked as a researcher in software engineering at
HP Laboratories for the past fve years. His interests are developing
formal specifcation languages and CASE tools to support them.
		

Object-Oriented Concurrent Programming
Sunday:	Full Day
Level:	Advanced
Jean-Pierre Briot, Institute Blaise Pascal, France

This tutorial treats object-oriented concurrent programming (OOCP) as
the natural generalization of object-oriented programming. OOCP
decomposes a large program into a collection of small modules that run
and interact concurrently and are capable of exploiting parallel
hardware. The tutorial describes various levels of integration between
object- oriented programming and concurrency, leading to the notion of
an active object, which unifes object and activity, message passing
and synchronization.

The tutorial introduces Concurrent Smalltalk to describe concepts,
constructs, and methodology. Examples include programming with
continuations, divide and conquer, and pipelining. It also shows how
to implement active objects, and uses Actalk as an example.  Finally,
it compares various OOP models and languages, with a special focus on
the Actor computation model.

Although the tutorial uses Smalltalk for examples, you don't need to
know Smalltalk to understand it; a quick introduction to Smalltalk
syntax is included.  It assumes that you understand object-oriented
programming well, but little more about concurrency than intuitive
concepts of processes and synchronization.

Jean-Pierre Briot is a researcher working at LITP, Institute Blaise
Pascal, Paris. He has performed tutorials on this topic at TOOLS and
ECOOP Conferences. He designed the Actalk testbed based on Smalltalk,
to model, classify, and experiment with various OOCP models in a
unifed programming environment. He is co-heading an Esprit parallel
computing action to develop an OOCP programming environment on
multiprocessors.


Types for the Working Programmer
Sunday:	Half Day-Morning
Level:	Advanced
Andrew Black, DEC

There has been recent progress in understanding types for
object-oriented languages, but most of it has had little or no impact
on real programmers.  This tutorial aims to extract from the confusion
those topics that are important to programmers who must use or choose
an object-oriented language. The tutorial explains the role of types
in object-oriented languages, what types can do for programmers, and
how the trend towards distributed and heterogeneous systems and
object-oriented databases influences what it means for a program to be
type-correct.

The tutorial describes the difference between objects and values, what
types are and why they are good for you, what refnement and subtyping
are, what problems they solve, and what problems they do not; why
contravariance isn't an unnatural act; why inheritance is a
relationship between programs, not between classes; what is the type
of nil, and whether it has one; and whether you should care that type
is not a type.

By the end of the tutorial, you will understand how abstract concepts
like subtyping can help you solve practical problems such as deciding
when one piece of code can be substituted for another.

Andrew Black is a research staff member at Digital Equipment
Corporation's Cambridge Research Lab and a Visiting Faculty Member at
Harvard University. Before joining Digital he was a faculty member at
the University of Washington in Seattle, where he was a co-designer of
the Emerald programming language. Dr. Black's research interests are
in operating systems, distributed systems, object-oriented programming
and programming language design, and most particularly in the space
where these areas overlap. His research goal is to make everything as
simple as possible, but no simpler.


Types for the Language Designer
Sunday:	Half Day-Afternoon
Level:	Advanced 
Michael Schwartzbach & Jens Palsberg,
Aarhus University, Denmark

The type systems of object-oriented languages have specifc goals: they
serve as partial documentation, they provide modularity, and they
ensure safety and efficiency at run-time.  There are many choices in
the design of a type system, and it is hard to evaluate their
tradeoffs. This tutorial teaches a coherent theory of type systems for
object-oriented languages that can be used for both explicit systems
(where the programmer supplies type annotations) and implicit systems
(where the compiler must perform type inference), and forty systems
based on interfaces, classes, and sets of classes.

The tutorial defnes an idealized object-oriented language, inspired by
Smalltalk, and develops several type systems for it. This uniform
framework makes it easy to compare different approaches. The tutorial
explores the limitations of static type checking and shows how dynamic
type checking can be introduced. It demonstrates how subclassing is
different from subtyping, how specifcation types differ from
implementation types, and the influence of a type system on separate
compilation.
	
This tutorial is for anyone interested in language design issues. If
you are not confdent of your ability to follow the issues, then you
should frst take tutorial 6.

Michael I. Schwartzbach is associate professor and Jens Palsberg is
research associate in the Computer Science Department of Aarhus
University. They have co-authored several papers on object-oriented
type systems and organized the ECOOP'91 Types Workshop.  They have
also worked on type systems for functional and procedural languages.


Simulation with DEVS-CLOS
Sunday:	Half Day-Morning
Level: Intermediate
Suleyman Sevinc, University of Sydney , Australia

This tutorial has two purposes: to show how the features of CLOS
affect a design and to describe the design of a general-purpose
simulation system. The tutorial is designed for those who want to
understand the practical importance of the unique features of CLOS and
also those who would like to learn how to use or build object-oriented
simulation systems.
	
The tutorial emphasizes the underlying model of object-oriented
programming in CLOS and distinguishes it from other models. It also
describes the requirements of a simulation system and the design of
DEVS-CLOS, a publicly available simulation system. DEVS-CLOS is an
extension to CLOS that supports modeling and simulation. It supports
visualization, supports hierarchical design of simulations, allows
frst-order logic in models, and supports adaptive system simulation.
The tutorial shows how a system like DEVS-CLOS can be used to solve
typical simulation problems, and how CLOS concepts like multimethods,
multiple inheritance, pre- and post-methods and dispatching algorithms
were used in the design of DEVS-CLOS.
	
Since receiving his Ph.D. from the University of Arizona, Dr. Sevinc
has been with the Basser Department of Computer Science, University of
Sydney, where he teaches software engineering, functional and
object-oriented programming, and both teaches and conducts research in
simulation, especially applying object-oriented programming, AI, and
logic to simulation systems. He often teaches C++, but is always happy
to introduce C++ programmers to the joy of CLOS.


Advanced CLOS and Meta-Object Protocols
Sunday:	Half Day-Afternoon
Level:	Advanced
Jon L. White, Lucid

One of the important characteristics of CLOS is its dynamic
flexibility to change descriptions, programs, and even data objects
"on the fly". A typical CLOS system is implemented by a set of
meta-objects, which can be changed by the programmer, essentially
letting you create a new language. Thus, CLOS is a reflective
programming language.

The main purpose of this tutorial is to teach you how to put a
meta-object protocol to a practical use. In addition to describing the
implementation of a typical CLOS system and discussing the various
issues raised by the book "Art of the Meta-Object Protocol", it gives
practical examples of meta-object extensions including techniques for
making user-defined metaclasses, for making alternations to SLOT-VALUE
so that certain slots can be "persistent", and for making metaclasses
whose classes automatically keep a table of all their instances.

The tutorial is aimed at the CLOS programmer or the programming
language expert who would like to learn more about reflective
programming using a meta-object protocol. The emphasis is on practical
uses of a meta-object protocol, not on the philosophy of reflection.

Jon L. White is Principal Scientist at Lucid, Inc. The frst Lisp
system that he developed was MacLisp, which he developed at the M.I.T.
A.I. Lab in the early 1970's. He also worked on NIL, InterLisp, and
Lucid Common Lisp. He is the editor of Lisp Pointers, an ACM SIGPLAN
publication devoted to Lisp.


Introduction to Object-Oriented Database Management Systems
Sunday:	Full Day
Level:	Intermediate
David Maier, Oregon Graduate Institute

This tutorial begins by explaining object-oriented database management
systems (OODBMS) in terms of what is the value added beyond
record-oriented database systems and object-oriented programming
languages. It presents most of the current commercial OODBMS and
several advanced prototypes with particular attention to
distinguishing them in their data models, application interfaces and
system architectures. It will also contrast the OODBMS approach with
extended relational systems. A goal of the tutorial is to give
participants an appreciation for the consequences of design choices
made in the different systems. It concludes with a critique of current
market offerings, and suggests there are signifcant regions of the
design space to explore, and needs of advanced applications that are
still largely unmet by any database product.

This tutorial is designed both for those considering investing in
OODBs and those who just want to understand the technology. It assumes
knowledge of object-oriented programming concepts, and some
familiarity with conventional database systems, particularly
relational databases.

David Maier is a professor at the Oregon Graduate Institute, where he
explores the principles, applications, and design of OODBMS. He was
involved in the design of Gemstone, one of the frst commercial OODBMS,
spent a sabbatical at Altair (predecessor of O2 Technology), is a
scientifc advisor for Object Design and is currently evaluating
GemStone, ObjectStore and Versant in scientifc data management.

Object-oriented Software Development with the Demeter Method
Sunday:	Half DayPAfternoon
Level:	Advanced
Karl Lieberherr, Northeastern University

The Demeter Method is a formal method that lifts object-oriented
software development to a higher level of abstraction by using a
graphical specifcation language for describing object- oriented
programs. Executable programs are automatically generated by a CASE
tool (the Demeter System/C++) from the graphical high-level
descriptions. Unlike other specifcation languages, the Demeter Method
allows you to keep the binding of methods to classes flexible under
changing class structures. The higher level of abstraction leads to
shorter and more reusable programs than by programming directly in one
of today's object-oriented languages such as C++, Smalltalk, Eiffel or
CLOS.

Because the Demeter Method is regularly taught at NU both at the
graduate and undergraduate level with the 10 week quarter system, it
has become, by necessity, very easy to learn.

This tutorial is for professionals who want to learn powerful,
formally defned high-level concepts that describe the programming task
in terms of data-model-based graphs and their subgraphs.

Karl Lieberherr is a Professor of Computer Science at Northeastern
University leading the Demeter Team working on methods and tools for
simplifying object-oriented software development. Members of his team
have published a paper every year since 1988, either at OOPSLA or
ECOOP or at both conferences.

Object-Oriented User Interfaces
Sunday:	Half Day-Morning
Level:	Intermediate
Dave Collins, IBM

The principles of objects, polymorphism, classes, and inheritance can
apply to the end user's external view of a user interface, just as it
can apply to the language that is used to implement it. This tutorial
shows how to design (not implement) a user interface that is truly
object- oriented. It gives guidance on the design of the "externals"
of object-oriented user interfaces, and shows how developers can
capitalize on the isomorphism between the user's conceptual model of
the interface and the constructs provided by object-oriented
programming languages. The tutorial exposes a (perhaps surprisingly)
deep analogy between object-oriented programming languages and
object-oriented user interfaces. This analogy is valuable because it
can be used to map "external" user interface design in a clear and
natural way onto object-oriented application frameworks. The tutorial
is illustrated with historical examples, many on videotape.

Dave Collins is an Institute Fellow in End User and Object-Oriented
Technologies (formerly the User Interface Institute) at the IBM Thomas
J. Watson Research Center, where he is working on object-oriented
tools for prototyping advanced user interfaces. Previously, he was a
Senior Instructor at the IBM Systems Research Education Center, where
he developed and taught courses on software usability, user interface
design, and object-oriented programming.


Evaluating Reusable Class Libraries
Sunday:	Half Day-Afternoon
Level:	Intermediate
Timothy Korson, Clemson University

Object-oriented technology not only affects the way we design
individual applications, it holds the potential of ushering in the
"software industrial revolution." A key to the success of object
technology is the widespread availability of high quality class
libraries. These class libraries are the re-usable parts of the
software industry.

This tutorial teaches how to evaluate object-oriented libraries. The
same criteria can be used for selecting commercial libraries or for
designing libraries for use in-house. The tutorial also describes
practical criteria for specifying and cataloging in-house corporate
software libraries. In addition to these technical criteria, the
tutorial also shows you the corporate infrastructure that is necessary
for enabling large scale reuse.

Timothy Korson is an assistant professor of Computer Science at
Clemson University, and president of the Consortium for the Management
of Emerging Software Technologies (COMSOFT). His current research and
consulting activities focus on the management of information assets
with emphasis on managing a corporate transition to object-oriented
technology.


Object Engineering 
Sunday:	Half Day-Morning
Level:	Intermediate
R. Stonewall Ballard,
Component Software Corporation

Converting an object-oriented design into class defnitions in an
object-oriented language often requires many engineering decisions. It
is easy to make these decisions incorrectly for languages that give
the programmer a lot of control over data representation, such as C++.
This tutorial covers low-level issues in building extensible and
evolvable programs, issues that are important if you want to build
well-balanced abstractions. It describes how to use multiple
inheritance properly in spite of the compiler, when to use forwarding
instead of inheritance, how to encapsulate state, and when to use
references instead of copying objects.

This tutorial teaches how to convert object-oriented designs into code
that is easy to extend and reuse. Many of the issues are more
interesting to C++ programmers than Smalltalk programmers, and C++ is
the language used for examples, but most of the issues are language
independent.

Stoney Ballard was introduced to object-oriented programming in 1974
at M.I.T. by Richard Steiger. He built DEC's Smalltalk-80 interpreter
as part of the roll-out of Smalltalk in 1981. He has been a graphics
and workstation designer at Perq Systems, a research scientist at
Xerox PARC, and a systems architect at On Technology. He is currently
founder and president of Component Software Corporation.


Teaching Object-Oriented Programming and Design
Sunday:	Half Day-Afternoon
Level:	Intermediate
James C. McKim Jr., Hartford Graduate Centre

A course in object-oriented programming and design should address the
claims made for the object-oriented paradigm, namely that it promotes
reuse, models the problem space, facilitates maintenance, incorporates
changes easily, and shortens the development lifecycle. One way
(perhaps the only way) for students to test such claims is to build a
small but high quality product as part of the course.

This tutorial shows how to have students in a conventional computer
science program build such a product, and addresses such issues as how
to pick good projects, whether and how students should work together
in teams, how to keep students on schedule, and how to divide a
project into a sequence of deliverables within the context of a one
semester course.

The tutorial also describes how to scale back the approach so that
students in short courses , common in industry, can get maximum beneft
in the limited time that is allowed.

James McKim is professor of Computer Science at the Hartford Graduate
Center, where he has been putting this approach into action and
fne-tuning it. He has more than twenty years experience teaching
mathematics and computer science, and has authored, co-authored and
reviewed many textbooks and articles.

Monday, October 19


Object-Oriented Project Management
Monday:	Full Day
Level:	Beginning
Kenneth Rubin & Adele Goldberg, ParcPlace

Object-oriented projects have to be managed properly to obtain the
most benefts from object-oriented technology. This tutorial explains
the effect of object-oriented technology on costs, staffng and choice
of methodology. It describes the pitfalls that attend object-oriented
projects so that you can avoid them, and explains the key processes,
including development style, use of prototyping, and reuse. It gives
specifc guidelines for organizing projects, managing a reuse library,
estimating the size and cost of projects, and introducing object-
oriented technology into an organization.

Kenneth S. Rubin is Professional Services Manager at ParcPlace Systems
where he manages the development of methodologies to support
successful object-oriented software engineering.

Adele Goldberg is Chairman of ParcPlace Systems, and author of several
books on Smalltalk-80. She is responsible for ParcPlace's overall
technology and methodology vision.


Introduction to Object-Oriented Design
Monday:	Half Day-Morning
Level:	Intermediate
Lori Stipp & Grady Booch, Rational 

This tutorial describes the Booch method for object-oriented design,
including details of the notation and the design process. It describes
the principles that are necessary for thinking and abstracting in
terms of classes and objects. The tutorial includes a number of
examples, including "war stories" from specifc projects. It also
covers extensions to the notation beyond that described in
Object-Oriented Design with Applications.

This tutorial is a condensed version of Booch's popular tutorial given
at past OOPSLA's. If you have attended that in the past then you
should attend tutorial 18 instead of this one.

Lori Stipp develops courseware on object-oriented analysis and design
for Rational. Before working at Rational, she spent 6 years at Aion
Corporation developing and applying methods for designing
object-oriented, knowledge-based systems.

Grady Booch is the Director of Object-Oriented Products at Rational
and an international consultant. He has pioneered applying
object-oriented design methods to a wide spectrum of object-oriented
and object-based languages.


The Pragmatics of Building Object-Oriented Systems
Monday:	Half Day-Afternoon
Level:	Advanced
Grady Booch, Rational 

This tutorial expands upon the process described in Booch's
Object-Oriented Design with Applications to provide a prescriptive,
iterative process for object-oriented development. It describes both
the macro and micro process of development. It gives guidelines for
managing iterative development, and addresses the pragmatic issues of
milestones and planning, staffng, integration and release management,
reuse, testing, quality assurance and metrics, documentation, tools,
and technology transfer.

This tutorial assumes that you are familiar with Booch's design
method. If you are not, but have a good understanding of
object-oriented concepts and design principles, you should take
tutorial 17 to be prepared for this tutorial.

Grady Booch is the Director of Object-Oriented Products at Rational
and an international consultant. He has pioneered applying
object-oriented design methods to a wide spectrum of object-oriented
and object-based languages.

A Case Study of Domain Analysis: Health Care 
Monday:	Half Day-Morning
Level:	Advanced
Martin Fowler & Thomas Cairns,
St Mary's Hospital Medical School , England 

Three years ago the UK National Health Service decided to develop a
generic model to describe all aspects of its management and operation.
Several projects were launched to describe the health care process
using the object-oriented modeling technique Ptech (now published by
James Martin and Jim Odell). One of these projects, the Cosmos
project, produced the Cosmos Clinical Process Model (or CCPM), which
describes the medical record. The CCPM contains approximately 70
object types in a highly abstract structure describing clinical
procedures, observations, evidence and assessment, accountabilities
and contracts, care planning, and clinical knowledge. The model has
gained widespread interest in both the UK and Europe and will be used
as the focus for a number of EEC sponsored projects, and is taking a
leading standardization role in Europe.

The CCPM is an example of the result of domain analysis. Its use of
abstractions, some of which are applicable outside health care, and
its use of an operational/knowledge divide can guide those working on
large-scale generic models in other areas. The tutorial describes the
relationship between generic and specifc models since these issues are
key in the acceptance of a highly generic application area model by
those with specifc applications to develop. The question of adapting
an object-oriented method for particular needs is also addressed.

Martin Fowler is an analyst and designer with previous experience with
Coopers & Lybrand UK and with ADT. For the last three years he has
been employed by the UK National Health Service to produce a generic
model for health care, which is the subject of tutorial 13. He also
teaches and consults on object-oriented analysis and design.

Thomas Cairns is a renal physician. He began object-oriented modeling
with the Cosmos project in 1989 and is the leading clinician in
developing the CCPM. He is also researching in transplantation and
immunology.

The Analysis and Design of Distributed Systems
Monday:	Half DayPAfternoon
Level:	Advanced
Mehmet Aksit, University of Twente

The design of distributed object-oriented systems involves a number of
considerations that rarely arise in sequential object-oriented design
or in non-object-oriented languages. The tutorial describes analysis
and design techniques for data abstraction, inheritance, delegation,
persistence, atomicity, concurrency, synchronization, and coordinated
behavior in a distributed object-oriented framework. Special attention
will be paid to the uniform integration of these concepts with the
object-oriented paradigm. Discussions will be accompanied by examples
that arose from constructing such systems.

Mehmet Aksit is an associate professor at the University of Twente. He
is a consultant for several companies, has presented a number of
tutorials and courses in Europe, and is the tutorial chair of this
year's ECOOP conference. His areas of interests are object-oriented
analysis and design methodologies, object-oriented CASE tools,
programming environments, languages and object based management
systems.


Specifcation Techniques for Object-Oriented Software
Monday:	Full Day
Level:	Advanced
Mahesh H. Dodani, University of Iowa

There are many techniques for specifying software. However, they are
not usually presented in a way that is directly applicable to
object-oriented software. This tutorial surveys both operational and
descriptive specifcation techniques, shows how to use them in several
popular object-oriented software engineering methods, and provides
case studies of developing useful, formal specifcation mechanisms that
are appropriate for object-oriented software engineering.
	
The tutorial frst describes criteria for choosing specifcation
mechanisms from both a theoretical (syntax and semantics, specifying
properties, reasoning about properties, verifcation) and practical
(ease of use, modularity, applicability, supporting tools)
perspective. These criteria are then used to survey several popular
operational (data flow diagrams, fnite state machines, and petri nets)
and descriptive (entity-relationship models, logic, and algebraic
specifcations) specifcation mechanisms. Finally it shows how to extend
two of these techniques (algebraic specifcations and fnite state
machines) so that they are suitable for object-oriented software
engineering.

Mahesh Dodani is an assistant professor of Computer Science at the
University of Iowa, where he has been developing a graduate curriculum
for object-oriented software engineering in response to demands from
local industry. He directs several groups conducting object-oriented
research, and has been involved in building object-oriented systems
ranging from interface builders to database design tools.


Writing Efficient C++ Programs
Monday:	Half Day-Morning
Level:	Intermediate
Scott Meyers, Brown University

This tutorial teaches the competing meanings of "high performance;"
the characteristics of object-oriented systems that can decrease
performance; how to locate and eliminate computational bottlenecks in
C++ programs; and the trade-offs between high performance and system
reusability, maintainability, and portability. It describes in detail
the factors that affect the performance of C++ software. Whether your
primary concern is high system speed, small system size, fast
recompilation, or a combination of these, this tutorial provides you
with the tools necessary to come up with an appropriate
object-oriented design, to implement it efficiently in C++, and to
fne-tune it for maximum performance.

The reasons for bottlenecks in C++ programs are often surprising.
Contrary to popular belief, virtual functions usually exact a
negligible performance cost, while unexpected calls to constructors
and destructors frequently hamstring applications. This tutorial
teaches you what is really important if you want to deliver high
performance, and the techniques you need to achieve it.
	
Scott Meyers has been teaching C++ in academic and industrial settings
since 1989. He is the author of "Effective C++"(Addison-Wesley, 1992),
and has authored or co-authored more than a dozen conference and
journal articles on software development, many of which deal
specifcally with C++.


The Design and Management of C++ Class Libraries
Monday:	Half Day-Afternoon
Level:	Intermediate
Arthuir Riel, Vanguard Training

Producing reusable C++ class libraries takes more than just knowing
the language: it requires careful design. This tutorial shows how to
create truly reusable C++ class libraries. It includes how to design a
minimal public interface, variable-size objects, memory leakage,
heuristics for operator overloading, designing reusable base-classes,
using inheritance and containment, and deciding how to place classes
in a class library.

Arthur Riel has over ten years experience programming in C and C++. He
has participated in the development of many large systems including
two real-time process control systems, a microcode assembler, 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. He is the founder
and editor of The C++ Insider, a bi-monthly newsletter specializing in
C++ design and implementation techniques. In addition, Arthur helps
spread the object-oriented gospel by teaching over twenty fve courses
(C++, OOD, OOP) per year in both corporate and academic environments.


Hardware Support for Object-Oriented Systems
Monday:	Half Day-Morning
Level: Advanced
Mario Wolczko, University of Manchester, England

When the performance penalty of object-oriented systems is mentioned,
a common response is to blame antiquated hardware designs for not
supporting object-oriented languages as they deserve. To what extent
can the performance gap between conventional languages and
object-oriented languages be closed using hardware? What architectural
changes beneft object-oriented systems, and by how much?

There have been many attempts to make hardware that better supports
object-oriented programming. This tutorial describes these systems,
and the extent that they have succeeded or failed in their aims. These
systems include SOAR, Rekursiv and MUSHROOM, as well as some features
from mainstream architectures such as SPARC. Issues covered include:
choice of instruction set, design of the memory system including
caches and virtual memory hardware, scaleability, use of parallelism,
and hardware/software trade-offs.

A common misconception is that if something is implemented in hardware
then it must be fast. One aspect of the tutorial is to show that there
are limits to what hardware support can achieve. However, better
hardware can reduce the cost of some language features, such as
dynamic binding, and can make a system more scaleable.

Mario Wolczko is a researcher in the Department of Computer Science at
the University of Manchester. He has been involved in the
implementation of object-oriented languages and systems for eight
years, most recently with the MUSHROOM project, which has been
investigating architectural support for object-oriented systems.


Efficient Implementation of Object-Oriented Programming Languages
Monday:	Half Day-Afternoon
Level:	Advanced
Craig Chambers, University of Washington
David Ungar, Sun Labs

This tutorial is for those who like to know how object-oriented
languages work "under the hood," why some things are expensive while
other things are cheap, and why language defnitions include certain
restrictions. This tutorial provides that, and more. It describes
features of object-oriented languages that are difficult to implement
efficiently, and how this has affected language designs. It describes
state-of-the-practice and state-of-the-art techniques for implementing
languages like C++ and Smalltalk.

Language features include dynamic binding and generic operations,
inheritance, user- defned control structures, static type systems,
multiple inheritance and virtual base classes, and mixing
object-oriented and non-object-oriented programming.

The tutorial also addresses questions like: What are the trade-offs in
using the various implementation techniques? What problems remain that
block more efficient object-oriented language implementations? What
might be promising areas for future research?

Craig Chambers and Dave Ungar are well-known for their work on Self, a
language even harder to make fast than Smalltalk. Craig is an
assistant professor at U. of Washington and Dave is at Sun
Microsystems Laboratories.


Constraint-Based Languages and Systems
Monday:	Half Day-Morning
Level:	Advanced
Bjorn Freeman-Benson , University of Victoria, Canada
Alan Borning, University of Washington

A constraint is a relation that should be satisfed, for example, that
a line remain horizontal, that a resistor in an electrical circuit
simulation obey Ohm's Law, or that the height of a bar in a bar chart
be proportional to some number in an application program. Constraints
have been used in a variety of languages and systems, particularly in
user interface tool kits, in planning and scheduling, and in
simulation. They provide an intuitive declarative style of programming
that integrates well with object-oriented systems.

This tutorial teaches what constraints are, how to use them in
applications such as user interfaces, how to implement them (including
how to implement constraint hierarchies), and how to embed them in
object-oriented and logic programming languages. You don't have to
know anything about constraints, but it would be helpful to have a
strong background in programming languages.

Bjorn Freeman-Benson is an assistant professor at the University of
Victoria. He worked for many years as a software engineer and recently
completed his Ph.D. at the University of Washington; his dissertation
was on the integration of constraint and imperative programming
languages. His research interests are in object- oriented languages,
constraint-based languages and systems, and user interfaces.

Alan Borning's Ph.D. thesis in 1979 was one of the frst on constraint
programming, and also one of the frst describing a system (ThingLab)
written in Smalltalk. Although his degree was from Stanford, he worked
with Alan Kay and the Learning Research Group at Xerox PARC.  He has
been at the University of Washington since 1980, where he is currently
an associate professor. His research interests are in object-oriented
languages, constraint-based languages and systems, and user
interfaces.

Visual Programming Languages from an Object-Oriented Perspective
Monday:	Half Day-Afternoon
Level:	Advanced
Allen L. Ambler, University of Kansas
Margaret M. Burnett,
Michigan Technical University

Visual programming language research has evolved greatly since its
early days. At frst, attempts at visual programming mostly took the
form of flowchart-like diagrams. But in recent years, a wide number of
innovative approaches have been incorporated into visual languages,
including object-oriented programming, form-based programming,
programming by demonstration, and dataflow programming. Unfortunately,
while many of these systems represent important ideas, only a few have
been successful as complete visual programming languages. This
tutorial explains why this is true, and describes ways in which the
problem can be addressed.

This tutorial explores the issues behind the successes and failures of
earlier approaches from a design perspective. It identifies
characteristics of successful visual programming languages, and
explains how to design an object-oriented language that maintains
those characteristics. It shows solutions to a number of problems by
looking at existing visual programming languages, including Prograph.

Allan L. Ambler is an associate professor in the Department of
Computer Science at the University of Kansas. He has led the design
and implementation of the visual programming languages Forms,
Forms/2,Forms/3, and PT, and is currently involved in the
development of a visual programming approach to scientifc
visualization.

Margaret M. Burnett is an assistant professor in the Department of
Computer Science at Michigan Technological University. In her recent
doctoral dissertation, working with Allen Ambler, Dr. Burnett
developed approaches to abstraction in visual languages, using these
approaches to solve several subproblems associated with using visual
programming languages for realistic programming.

Intermediate Smalltalk: Practical Design and Implementation
Monday:	Half Day-Morning
Level:	Intermediate
Trygve Reenskaug, TASKON , Norway

Careful design before programming is as important in Smalltalk as in
other languages. This tutorial describes techniques that have proven
useful in commercial development of large Smalltalk systems. The
tutorial shows how to develop a language independent design and then
go to detailed programming and testing. The examples will be based on
Smalltalk-80 and use the release 4.1 graphical user interface
framework.

Trygve Reenskaug started using Smalltalk-76 when he visited Xerox PARC
in the 70's, where he introduced the idea of model/view/controller,
and has been developing in Smalltalk ever since. He is responsible for
research at Taskon A/S in Oslo and is Professor of Informatics at the
University of Oslo. He has been involved in software engineering and
the development of software products since 1958.


Writing Efficient Smalltalk Programs
Monday:	Half Day-Afternoon
Level:	Intermediate
Ken Auer, Knowledge Systems Corp.

Smalltalk has a reputation for being slow and a memory hog. In
reality, the Smalltalk environment offers many ways to create
inefficient code, and programmers often exploit those opportunities.
However, there are just as many ways to create efficient code, some of
which may not be available in more traditional languages. Whether an
application is efficient or not has more to do with the way the
programmer has used the available tools than the tools themselves.

This tutorial teaches Smalltalk programmers how to write efficient
programs. The emphasis is on how to exploit, rather than sacrifce, the
benefts of good object-oriented design. You should have at least six
months experience with Smalltalk writing non-toy programs to get the
most beneft from the tutorial.

Ken Auer is a senior member of the technical staff at Knowledge
Systems Corporation. He has been applying Smalltalk to real-world
problems since 1985, serving as a chief architect of several large
object-oriented systems. Ken has concentrated his efforts on
developing quality reusable components and frameworks, and teaching
others to do the same.


Testing Object-Oriented Software
Monday:	Full Day
Level:	Intermediate
Edward Berard, Berard Software Engineering

Testing of object-oriented software is just as important as testing
non-object-oriented software, but the process is fundamentally
different because of such factors as information hiding,
encapsulation, and inheritance. This tutorial teaches you the terms
and concepts of testing software in general, and object-oriented
software in particular; how to apply a number of different testing
techniques to object-oriented software; how to construct test cases;
and an appreciation of what is involved in planning a successful
software testing effort. The testing techniques that are covered
include both white-box testing such as basis path testing and coverage
testing, and black-box testing techniques such as equivalence class
partitioning and boundary value analysis.

This course is designed for those with experience in object-oriented
software engineering who would like to follow a more rigorous approach
to testing.

Edward V. Berard is the founder and President of Berard Software
Engineering, Inc. He has nearly twenty years of software-related
experience in varied environments, with the last decade being spent in
the area of object-oriented software engineering. He is best known for
his efforts in the areas of object-oriented approaches to the software
life-cycle, software reusability, software engineering metrics, and
software engineering education.


Object-Oriented Geometry and Graphics
Monday:	Half Day-Morning
Level:	Intermediate
Jan Krc-Jediny & Augustin Mrazik, ArtInAppleS, Czechoslovakia

Spatial information is an important part of geographic information
systems, CAD and CAM systems, and user interfaces for visualization of
any kind of information. The object-oriented approach to spatial
object modelling results in much more understandable designs than non-
object-oriented approaches.

This tutorial describes the design of several key components of a
system for dealing with spatial information which are: analytical
geometry closed with respect to union, intersection and complement
operations; hierarchically structured objects for maintaining
topological information; object identity and problems arising from
change of spatial objects in the database and user interface,
transactions and copies of objects; dependencies of spatial objects
and their copies in the MVC user-interface architecture.

You should have experience in building user-interfaces and should have
some background in analytical geometry. Examples are shown in
Smalltalk, so a basic knowledge of Smalltalk would be helpful.

Jan Krc-Jediny is a researcher and developer at ArtInAppleS Ltd.,
Bratislava, Czeckoslovakia. His main area of interest is
object-oriented graphics and hypermedia systems. Before joining
ArtInAppleS he spent 15 years at the Department of Applied Mathematics
of the Commenius University in Bratislava in research and development
of computer graphics systems and standards.

Augustin Mrazik is co-founder and president of ArtInAppleS Ltd. His
main interest is object-oriented spatial information processing,
knowledge representation and object-oriented GIS.  He led the
development and implementation of the Spacetalk system,which was
demonstrated at OOPSLAT89.


The Design of an Object-Oriented Operating System: A Case Study of Choices
Monday:	Half Day-Afternoon
Level:	Intermediate
Roy H. Campbell & Nayeem Islam,
University of Illinois 
Peter M Madany, SUN Microsystems

This tutorial describes the object-oriented design of a complete
operating system, written to be object-oriented, with a user and
application interface that is object-oriented. The main objective is
to illustrate object-oriented design trade-offs by studying a large
object-oriented system, the Choices operating system.

Choices is an object-oriented multiprocessor operating system that
runs native on SPARC stations, Encore Multimaxes, and IBM PCs. The
system is built from a number of frameworks that implement a general
fle system, persistent store for persistent objects, process
switching, parallel processing, distributed processing, interrupt
handling, virtual memory, networking, and interprocess communication.

If you bring a 386-based portable computer running MS-DOS to the
course then you may experiment by writing application programs for
PC-Choices. All participants will receive a copy of PC-Choices on a
floppy.

Participants should have experience with building object-oriented
systems and have a basic understanding of operating systems design.
Reading knowledge of C++ is helpful, but not necessary.

Roy Campbell is a professor of Computer Science at the University of
Illinois at Urbana-Champaign, where his research interests include
software engineering, operating systems, and networking.

Peter Madany recently fnished his Ph.D. thesis at the University of
Illinois on a framework for fle systems and persistent storage, and is
now at Sun Microcomputer Laboratories.

Nayeem Islam is a Ph.D. candidate and a member of the Choices project
at the University of Illinois, and has published several papers on
distributed and object-oriented programming.


Teaching "Object-Think" with Multi-Sensory Engagement
Monday:	Half Day-Morning
Level:	Advanced
Peter Coad, Object International, Inc.

This is a tutorial about how to teach the "big picture" of objects,
especially in an industrial environment where time is short. It is
based on the whole brain theory and multi-sensory engagement. The
tutorial shows over twenty specifc techniques for teaching using
multi-sensory engagement, many of these unifed into "The Object
Game", which lets those new to objects see and manipulate them. The
tutorial describes a set of specifc techniques for leading someone
into more effective "object think", and compares and contrasts
whole-brain multi-sensory engagement with other "object think"
techniques, such as graphics, languages, and CRC cards.

This tutorial is designed for those trying to teach object-oriented
development who have been frustrated by the inability of some people
to reach effective "object think". It will also be of interest to
those planning to teach object-oriented programming, or those
responsible for selecting such a course.

Peter Coad builds an average of ten object-oriented models each month
for clients and seminar participants in a wide range of industries.
Teaching is one of the things he enjoys best, and he has been
developing the techniques described in this tutorial as a way to
become more effective and solve the problems that plague all those
teaching about objects.  He is the author (with Ed Yourdon) of
Object-Oriented Analysis, Second Edition and Object- Oriented Design
and (with Jill Nicola) of Object-Oriented Programming (Fall 1992).


Schema Updates for Object-Oriented Database Systems
Monday:	Half Day-Afternoon
Level: Intermediate
Roberto Zicari , Johann Wolfgang Goethe University, Germany

OODBMS are often used for complex data whose structure is likely to
change over time, yet the problem of schema updates has not been
completely solved by any commercial or research OODBMS. This tutorial
describes the schema modifcation problem and why it is important, what
is really offered by products, what a good solution would be like, and
whether we are likely to see it soon.

The tutorial reviews several commercial OODBMS products that provide
facilities for updating the schema, namely: GemStone (Servio
Corporation), ITASCA(Itasca), O2(O2Technology), ObjectStore
(ObjectDesign), Ontos (Ontologic) and Statice (Symbolics). It also
describes the solutions proposed in some experimental research
prototypes and the open problems that remain.

Roberto Zicari is full professor of Computer Science (Databases and
Information Systems) at the Johann Wolfgang Goethe-Universitaet,
Frankfurt am Main, Germany. His current research and professional
interests are in object-oriented database systems and their
applicability to complex applications.