USENIX C++ CONFERENCE: TUTORIAL AND TECHNICAL PROGRAMS
Carolyn Carr
carolyn at usenix.ORG
Fri Apr 12 07:57:39 AEST 1991
USENIX C++ TUTORIAL PROGRAM
Monday - Tuesday, April 22-23, 1991
Washington, D.C.
****************************************************************
Tutorial Code: M1
Title: An Introduction to C++ (for C Programmers)
Instructor: Robert Murray, AT&T Bell Laboratories; Editor,
The C++ Report
Intended audience:
Program designers and developers with a good knowledge of C.
Knowledge of C++, data abstraction, or object-oriented
programming is not required.
Course Description:
A survey of the main features of C++ (including version 2.1) will
be presented, along with some short examples that show how to use
the features effectively. Most use of C++ falls into one of
three flavors:
- a better C,
- data abstraction,
- and object-oriented programming.
We will examine these flavors, starting with the features and
paradigms that are closest to C, and progressing to the more
ambitious (and potentially more powerful) features. The tutorial
does not attempt to exhaustively cover every single feature of
the language. Instead, it will concentrate on small examples that
demonstrate the most important concepts, including the design of
a simple (but useful) String class. A firm understanding of these
concepts will give students what they need to begin developing real
C++ programs. We will also discuss the relationship between C++
1.2, C++ 2.1, and ANSI C.
About the author:
Rob Murray is a Supervisor in the Software Systems Department,
AT&T Bell Laboratories. His job responsibilities include giving
presentations on C++ to research and development organizations
across Bell Labs, investigating advanced C++ compilation
techniques, and developing reusable C++ components and tools. He
has presented C++ tutorials at USENIX conferences since 1987.
Tutorial Code: M2
Title: C++ Programming Style
Instructor: Tom Cargill, Consultant
Intended Audience:
The tutorial will be of value to programmers who are starting to
program in C++, or have a reading knowledge, and are looking for
guidance on how to use its features in practice. Knowledge of C++
language basics is assumed. If need be, advanced language
features are clarified briefly. The material is code intensive,
for programmers who like to read and understand programs.
Course Description:
C++ supports programming-in-the-large, allowing relationships
between different parts of a program to be described. The scope
of C++ programming style therefore goes beyond the issues of
traditional programming-in-the-small, such as indentation and the
use of goto. This tutorial examines the use of language features
that often confuse a novice, including (multiple) inheritance,
virtual functions, constructors, destructors, function and
operator overloading, default arguments and static members.
Unwarranted use of the more powerful features leads to cluttered
programs that are harder to comprehend, and in some cases less
efficient, than more straightforward alternatives. In this
tutorial we examine, and then simplify, a number of programs.
The techniques range from simple rules of thumb about
constructors to transformations that remove redundant
inheritance.
We read programs, discuss their organization and use of C++,
critique the design, redesign where necessary, and then recode.
The discussion ranges from questions of data abstraction and
object-oriented design to the expression of a given design in
C++. Design and coding style guidelines are distilled from the
examples.
About the author:
Tom Cargill started programming in C++ when the language was
called "C84," at the Computing Science Research Center, AT&T Bell
Labs, Murray Hill, NJ. He wrote one of the first major C++
programs, a family of portable, distributed debuggers. He has
continued to use C++, presenting his experience in papers and
tutorials at numerous technical conferences. Teaching C++
courses regularly, Tom is the author of Addison-Wesley's TEC C++
course. Currently a software consultant, based Colorado, he
he holds a Ph.D from the University of Waterloo.
Tutorial Code: T1
Title: Library Design and Management in C++
Instructor: Dr. James M. Coggins, Computer Science Department
University of North Carolina at Chapel Hill
Intended Audience:
C++ programmers who are ready to begin developing class
libraries for their own use, especially for scientific and
engineering applications.
Course Description:
C++ provides several desirable code packaging mechanisms. We
still require decision criteria for designing the architecture of
class libraries (i.e., "What are the Objects?") along with
management strategies for accessing and maintaining the libraries.
This tutorial presents a decision criterion for identifying
appropriate class definitions based on a particular "separation of
concerns" objective. One consequence of this design criterion is
that the library's clients can contribute early and effectively to
the design process.
A strategy for managing the library's resources will be
presented. This strategy, in use in academia and industry, is
based on commonly available UNIX utilities such as make and RCS.
The strategy minimizes the overhead required in client programs to
engage the library's capabilities and to simplify library
maintenance.
The afternoon session will begin by explaining what C++ offers to
scientific and engineering programming, stating the case for
considering a switch from FORTRAN to C++ and offering alternatives
for managing that conversion for individual programmers and for
whole shops.
Libraries for scientific and engineering applications often depend
on a few crucial insights about the nature of their target
domains. Examples of such key insights will be offered from the
fields of dynamic simulation, medical image processing and
analysis, parallel computing, telecommunications, scientific data
visualization, fluid dynamics, and computer graphics, including
user interfaces.
About the author:
Dr. Coggins teaches Software Engineering, Image Processing and
Pattern Recognition, and Computer Vision and Graphics at UNC-Chapel
Hill. Dr. Coggins is a columnist for the international newsletter,
the C++ Report, and was a member of the program committee for the
1990 USENIX C++ Technical Conference. Besides frequent
presentations on C++ and library design in industry and academia,
he has published articles on library design and management
strategies in the 1990 USENIX conference, the C++ Report, and the
C++ Journal and SIGPLAN Notices.
Tutorial Code: T2
Title: Using C++ Effectively
Instructor: Andrew Koenig, AT&T Bell Laboratories
Intended audience:
The speaker intends to be comprehensible to people who have
previously taken Rob Murrary's "Introduction to C++," and who are
also experienced programmers in some other language (not
necessarily C). People who have programmed in C++ for some time
also benefit fromt the tutorial. They certainly will see things
they have seen before, but often these are shown in a new light.
Course description:
The tutorial emphasizes "how to use C++" well," rather than "what
are the features of C++." Based on a detailed look at several
programming examples, we discuss strategy and techniques in writing
C++ programs. Topics include:
- writing classes whose objects behave as values
- controlling memory allocation through use counts
- writing object-oriented programs
- function objects and related techniques
- C++ traps and pitfalls
About the author:
Andrew Koenig is a member of the Software Systems Department of AT&T
Bell Laboratories, where most recently he participated in making
AT&T's C++ 2.0 product ready for release. He has written several
C++ library packages now in use inside AT&T, contributes a regular
C++ column for the Journal of Object-Oriented Programming, and is
author of C Traps and Pitfalls.
Tutorial Code: T3
Title: Decomposition/Generalization Methodology for C++ Programs
Instructor: Vaclav Rajlich, professor, Department of Computer Science,
Wayne State University
Intended audience:
The tutorial will be of value to programmers, system analysts,
and managers who have at least a reading knowledge of C++, and
are looking for guidance how to use its features. Advanced
language features are clarified briefly.
Course description:
This tutorial introduces a methodology, called
Decomposition/Generalization, for top-down development of
object oriented systems. The methodology is a variant of
stepwise refinement extended to object oriented systems and
the C++ language. The course utilizes several examples to
illustrate the methodology.
The Decomposition/Generalization methodology alleviates the
difficulty of "finding the right objects". It is compared to
several other object oriented methodologies, in particular
Coad/Yourdon, Booch, and Object Oriented Structured Design.
About the author:
Vaclav Rajlich has published numerous papers in software
methodologies and tools. He has been particularly interested
in methodologies for object-based languages (Ada) and object
oriented languages (C++).
He is a professor and former chairman of the Department of
Computer Science at Wayne State University. Before that he
was with the University of Michigan in Ann Arbor.
_____________________________________________________________________
For registration and additional information please contact:
Judy DesHarnais
USENIX Conference Office
22672 Lambert Blvd., Suite 613
El Toro, CA 92630
Phone: 714/588-8649
FAX: 714/588-9706
**********************************************************************
USENIX C++ TECHNICAL PROGRAM
Wednesday and Thursday, April 24 -25, 1991
Washington, D.C.
*********************************************************************
Wednesday, April 24
8:45am Keynote Address
C++ + Persistence != An Object-Oriented DBMS
David DeWitt (University of Wisconsin)
Abstract
Currently, a number of companies and research projects
are building systems that add persistence to C++
in order to provide a solution to the database
needs of both VLSI and mechanical CAD systems and software
development environments. This talk will contrast the different
strategies being pursued and will examine the advantages and
disadvantages of each approach.
Biography
David J. DeWitt is a faculty member of the Computer
Sciences Department at the University of Wisconsin.
He is currently a member of the Technical Advisor Board
for Objectivity and the Parallel Processing Advisor Board for NCR.
Over the past 5 years he has managed the EXODUS extensible database
system project at Wisconsin which is attempting to address
the problems posed by emerging applications of database system
technology including GIS, CAD/CAM, and scientific applications.
The tools provided by EXODUS include E, a persistent version of C++,
the Exodus Storage Manager for storing persistent objects,
and the extensible, object-oriented DBMS, EXTRA and EXCESS.
10:15am Break
10:45am Experience Chair: Doug Lea
The Interaction of Pointers to Members and Virtual Base Classes in
C++ Randall Meyers (Digital Equipment)
Problems Involved in Extending Classes in C++
Martin Carroll (AT&T Bell Laboratories)
Automatic Detection of C++ Programming Errors:
Initial Thoughts on a lint++
Scott Meyers, Moises Lejter (Brown University)
12:15pm Lunch
1:30pm Class design Chair: Jim Waldo
The Features of the Object-oriented Abstract Type Hierarchy (OATH)
Brian Kennedy (Texas Instruments)
The Separation of Interface and Implementation in C++
Bruce Martin (Hewlett-Packard)
Signature-Based Polymorphism for C++
Elana Granston (Illinois at Urbana-Champaign)
Vincent Russo (Purdue University)
3:00pm Break
3:30pm Panel: How Useful is Multiple Inheritance in C++?
Chair: Andrew Koenig
Panelists: Tom Cargill, Keith Gorlen, Rob Murray, Mike Vilot
6:00pm USENIX reception
********** Thursday, April 25 ***********
8:30am Environments Chair: Jonathan Shopiro
Copying Garbage Collection in C++
Daniel Edelson, Ira Pohl (UC Santa Cruz)
Type Identification in C++
Dmitry Lenkov, Shankar Unni, Michey Mehta (Hewlett-Packard)
Representing Semantically Analyzed C++ Code with Reprise
David Rosenblum, Alexander Wolf (AT&T Bell Laboratories)
10:00am Break
10:30am Concurrent and Distributed Applications Chair: Rob Seliger
Porting and Extending the C++ Task System with the Support of
Lightweight Processes
Philippe Gautron (Rank Xerox France and LITP)
Concurrent Real-Time Music in C++
David Anderson, Jeff Bilmes (UC Berkeley)
DVOPS - A Tool for Developing Communication Protocols and
Distributed Applications
Juha Koivisto, Juhani Malka, James Reilly (Technical Research
Center of Finland)
12:00 Lunch
1:30pm Class Libraries Chair: Keith Gorlen
Experiences in the Design of a C++ Class Library
Mary Fontana, Martin Neath (Texas Instruments)
Pragmatic Issues in the Design of Flexible Libraries for C++
Douglas Hahn, Neil Soiffer (Tektronix)
A Network Toolkit
Walter Milliken, Gregory Lauer (BBN)
3:00pm Break
3:30pm Applications Chair: Vince Russo
An AWK to C++ Translator
Brian Kernighan (AT&T Bell Laboratories)
A Class Library for Solving Simultaneous Equations
Christopher Van Wyk (Drew University)
LogiC++: An Integrated Logic and Object-Oriented Programming
Language
Shanun-inn Wu (University of Minnesota)
*****
For registration and additional information please contact:
Judy DesHarnais
USENIX Conference Office
22672 Lambert Blvd., Suite 613
El Toro, CA 92630
Phone: 714/588-8649
FAX: 714/588-9706
More information about the Comp.org.usenix
mailing list