USENIX C++ Conference

Carolyn Carr carolyn at usenix
Sat Mar 9 05:27:25 AEST 1991


	    Monday - Tuesday, April 22-23, 1991

		    Washington, D.C.


Tutorial Code: M2
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: 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 capabilitites and to simplify library

    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: 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

    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

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
    holds a Ph.D. from the University of Waterloo.

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.

Biography of 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.



	   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)


    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.


    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
    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 mailing list