%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.06",
%%%     date            = "19 September 2010",
%%%     time            = "10:40:45 MDT",
%%%     filename        = "cppreport.bib",
%%%     address         = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone       = "+1 801 581 5254",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "48421 8519 42422 408987",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "BibTeX, bibliography, C++ Report",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This is a bibliography of publications in the
%%%                        magazine C++ Report (CODEN CRPTE7, ISSN
%%%                        1040-6042), published by SIGS Publications.
%%%
%%%                        At version 1.05, the year coverage looked
%%%                        like this:
%%%
%%%                             1991 (  21)    1994 (  21)    1997 (  25)
%%%                             1992 (  34)    1995 (  26)
%%%                             1993 (  26)    1996 (  81)
%%%
%%%                             Article:        234
%%%
%%%                             Total entries:  234
%%%
%%%                        The journal has a World-Wide Web site at
%%%                        http://www.sigs.com/publications/docs/cppr/.
%%%
%%%                        This bibliography has been collected from
%%%                        bibliographies in the author's personal
%%%                        files, from the journal's Web site contents
%%%                        files, and from the IEEE INSPEC database
%%%                        (1991--1995).
%%%
%%%                        Numerous errors in the sources noted above
%%%                        have been corrected.   Spelling has been
%%%                        verified with the UNIX spell and GNU ispell
%%%                        programs using the exception dictionary
%%%                        stored in the companion file with extension
%%%                        .sok.
%%%
%%%                        BibTeX citation tags are uniformly chosen
%%%                        as name:year:abbrev, where name is the
%%%                        family name of the first author or editor,
%%%                        year is a 4-digit number, and abbrev is a
%%%                        3-letter condensation of important title
%%%                        words. Citation tags were automatically
%%%                        generated by software developed for the
%%%                        BibNet Project.
%%%
%%%                        In this bibliography, entries are sorted in
%%%                        publication order, using bibsort -byvolume.
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================

@Preamble{"\input path.sty" #
          "\hyphenation{
                para-digm
                para-digms
                Call-eens
                Dasch-bach
                Thor-sten
          }"}

%%% ====================================================================
%%% Acknowledgement abbreviations:

@String{ack-nhfb = "Nelson H. F. Beebe,
                    University of Utah,
                    Department of Mathematics, 110 LCB,
                    155 S 1400 E RM 233,
                    Salt Lake City, UT 84112-0090, USA,
                    Tel: +1 801 581 5254,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://www.math.utah.edu/~beebe/|"}

@String{ack-rc = "Roman Czyborra,
                  e-mail: \path=|czyborra@dds.nl|"}

%%% ====================================================================
%%% Journal abbreviations:

@String{j-C-PLUS-PLUS-REPORT    = "C++ Report"}

%%% ====================================================================
%%% Bibliography entries:

@Article{Booch:1991:CLD,
  author =       "G. Booch and M. Vilot",
  title =        "{C++} library design",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "6",
  pages =        "10--14",
  month =        jun,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The authors examine some design issues involved in
                 providing class libraries in C++. Library design is a
                 natural consequence of object-oriented design (OOD),
                 where we model the key abstractions of the problem
                 domain. Over time, the library components become the
                 reuseable elements of new applications. The authors
                 take a look at four aspects of C++ library design: the
                 separation of interface from implementation;
                 architectures other than the Smalltalk single-tree
                 approach; the increasing scale of libraries; and
                 performance concerns and steps toward resolving them.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110B (Software engineering techniques); C6140D (High
                 level languages)",
  classification = "C6110B (Software engineering techniques); C6140D
                 (High level languages)",
  keywords =     "abstractions; C language; C++ library design; Class
                 libraries; class libraries; Design issues; design
                 issues; elements; Interface; interface; key; Key
                 abstractions; Library components; library components;
                 Object-oriented design; object-oriented design;
                 object-oriented programming; Performance concerns;
                 performance concerns; Problem domain; problem domain;
                 reusability; reuseable; Reuseable elements; Smalltalk
                 single-; Smalltalk single-tree approach; software;
                 subroutines; tree approach",
  thesaurus =    "C language; Object-oriented programming; Software
                 reusability; Subroutines",
  treatment =    "P Practical",
}

@Article{Horstmann:1991:FLA,
  author =       "C. S. Horstmann",
  title =        "A first look at programming {Windows} with {C++\slash
                 Views} and {Borland C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "6",
  pages =        "15--18, 24",
  month =        jun,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A discussion is given on the author's experiences with
                 a C++ class library for programming under Microsoft
                 Windows: C++/Views Version 1.1, CNS Inc. The author
                 used the class library in conjunction with the Borland
                 C++ compiler (Version 2.0). His background makes him
                 the perfect guinea pig to find out whether someone who
                 knows C++ but essentially nothing about Windows can
                 become a productive Windows programmer with a toolkit
                 like C++/Views. He concludes that the answer is a
                 definite `yes'.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Math. and Comput. Sci., San Jose State Univ.,
                 CA, USA",
  classcodes =   "C6110 (Systems analysis and programming); C6140D (High
                 level languages); C6180 (User interfaces)",
  classification = "C6110 (Systems analysis and programming); C6140D
                 (High level languages); C6180 (User interfaces)",
  corpsource =   "Dept. of Math. and Comput. Sci., San Jose State Univ.,
                 CA, USA",
  keywords =     "Borland C++; Borland C++ compiler; C language; C++
                 class library; C++/Views; compiler; graphical user
                 interfaces; Microsoft Windows; packages; programming;
                 software; Windows programmer",
  thesaurus =    "C language; Graphical user interfaces; Programming;
                 Software packages",
  treatment =    "A Application; P Practical; R Product Review",
}

@Article{Druker:1991:WCD,
  author =       "S. Druker",
  title =        "`What's that compiler doing, anyway?' --- virtual
                 function overhead",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "6",
  pages =        "19--20",
  month =        jun,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A programmer's best friend in C++ is a virtual
                 function. This is the primary vehicle for extending a
                 program, library, or other package of software. With
                 the appropriate design in mind, a clever programmer can
                 design years of value into a package written today. The
                 author presents a view of what goes on behind the
                 scenes of the Zortech C++ compiler for DOS in
                 implementing virtual functions and pointers to member
                 functions. This particular scheme has several
                 attractive features. The space required in the objects
                 themselves does not grow in the presence of multiple
                 inheritance in the language, unless the object
                 concerned inherits multiply somewhere. It lends a
                 natural and efficient implementation for pointers to
                 member functions. The technique uses an old idea called
                 thunks to implement these things. In the examples, a
                 notation is used to represent conceptual ideas. This
                 notation looks a lot like the programming language C
                 even though the compiler may not go through a C
                 translation phase.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150C (Compilers, interpreters and other processors);
                 C6140D (High level languages); C6120 (File
                 organisation); C6110 (Systems analysis and
                 programming)",
  classification = "C6110 (Systems analysis and programming); C6120
                 (File organisation); C6140D (High level languages);
                 C6150C (Compilers, interpreters and other processors)",
  keywords =     "C language; C++; conceptual; Conceptual ideas; data
                 structures; DOS; ideas; Member functions; member
                 functions; Multiple inheritance; multiple inheritance;
                 Pointers; pointers; program compilers; programming;
                 Programming language C; programming language C; Thunks;
                 thunks; Virtual function; virtual function; virtual
                 storage; Zortech C++ compiler",
  thesaurus =    "C language; Data structures; Program compilers;
                 Programming; Virtual storage",
  treatment =    "P Practical",
}

@Article{Coggins:1991:WDP,
  author =       "J. M. Coggins",
  title =        "Why does this program run so long?",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "6",
  pages =        "21--24",
  month =        jun,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Conventional wisdom suggests that C++ code tends to be
                 somewhat slower than corresponding C code. Some real
                 data supports the opposite position: that C++ code can
                 be faster than corresponding C code. The author shows
                 that C++ can be competitive with C in execution speed,
                 but the programmer must exercise some caution in
                 developing elegant C++ expressions or be ready to pay
                 the price in performance. The trade-off between
                 elegance and pragmatics is a familiar one. The one
                 examined is a particularly dramatic instance involving
                 the operator+() function.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., North Carolina Univ., Chapel
                 Hill, NC, USA",
  classcodes =   "C6140D (High level languages); C6110 (Systems analysis
                 and programming)",
  classification = "C6110 (Systems analysis and programming); C6140D
                 (High level languages)",
  corpsource =   "Dept. of Comput. Sci., North Carolina Univ., Chapel
                 Hill, NC, USA",
  keywords =     "C code; C language; C++ code; elegant C++; Elegant C++
                 expressions; Execution speed; execution speed;
                 expressions; Performance; performance; Pragmatics;
                 pragmatics; Programmer; programmer; programming",
  thesaurus =    "C language; Programming",
  treatment =    "P Practical",
}

@Article{Steinhoff:1991:SV,
  author =       "D. Steinhoff",
  title =        "{Saber-C++} version 1.0",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "6",
  pages =        "26--27, 30",
  month =        jun,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Saber Software has been shipping Saber-C++, their new
                 C++ programming environment, since 1990. This
                 second-generation tool builds upon the obvious success
                 of their earlier programming environment, Saber-C. Many
                 of the incremental programming and dynamic debugging
                 techniques they brought to UNIX with that earlier
                 product are present and expanded. Saber-C++
                 incorporates class, data, and file browsing, debugging,
                 incremental linking and a C++ interpreter into an
                 integrated environment. The product includes a slightly
                 modified (though `bug-compatible') version of cfront
                 2.0. In short, this is a tool for serious programming.
                 Programmers limping along with dbx and dbxtool or
                 similar tools should sit up and take note that this is
                 an order of magnitude improvement over what they are
                 used to.",
  acknowledgement = ack-nhfb,
  affiliation =  "Appl. Dynamic Int., Ann Arbor, MI, USA",
  classcodes =   "C6115 (Programming support); C6110 (Systems analysis
                 and programming); C6140D (High level languages)",
  classification = "C6110 (Systems analysis and programming); C6115
                 (Programming support); C6140D (High level languages)",
  corpsource =   "Appl. Dynamic Int., Ann Arbor, MI, USA",
  keywords =     "C language; C++; C++ interpreter; C++ programming
                 environment; dynamic debugging; Dynamic debugging
                 techniques; File browsing; file browsing; Incremental
                 linking; incremental linking; Incremental programming;
                 incremental programming; Integrated environment;
                 integrated environment; interpreter; programming
                 environments; Saber-C; Saber-C++; second-generation;
                 Second-generation tool; software packages; techniques;
                 tool",
  thesaurus =    "C language; Programming environments; Software
                 packages",
  treatment =    "P Practical; R Product Review",
}

@Article{Booch:1991:ODC,
  author =       "G. Booch and M. Vilot",
  title =        "Object-oriented {design-C++} class categories",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "7",
  pages =        "6--10",
  month =        jul # "-" # aug,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Looks at the design issues involved in defining the
                 contents of class libraries. A library designer has to
                 make many design decisions and many C++ language
                 features can support these decisions. They describe
                 some design idioms, or styles of use, of C++ features
                 employed in building libraries. They discuss some kinds
                 of C++ classes and how they can be used in libraries or
                 applications. Note that none of these styles of class
                 design are directly enforced by the language; they are
                 merely design conventions. They give each of the kinds
                 of classes a name to encourage a consistent use of
                 terms among C++ library designers.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming)",
  classification = "C6110 (Systems analysis and programming)",
  keywords =     "C language; C listings; C++ classes; C++ language; C++
                 language features; class design; Class design; Class
                 libraries; class libraries; features; object-oriented
                 design; Object-oriented design; object-oriented
                 programming",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Eckel:1991:CIC,
  author =       "B. Eckel",
  title =        "Containers and iterators in {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "7",
  pages =        "12--13",
  month =        jul # "-" # aug,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The C++ language is all about creating and using
                 types. One of the important features of types in C++ is
                 the level of safety that can be built into them. The
                 author discusses two concepts in object-oriented
                 programming that allows one to take the raw forms shown
                 (the array and the index) and convert them into safe,
                 general-purpose abstractions for all types, not just
                 built-in types. These abstractions are called
                 containers and iterators and they will make code easier
                 to write and more robust.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming); C6140D (High
                 level languages)",
  classification = "C6110 (Systems analysis and programming); C6140D
                 (High level languages)",
  keywords =     "Array; array; C language; C listings; C++ language;
                 Containers; containers; General-purpose abstractions;
                 general-purpose abstractions; Index; index; Iterators;
                 iterators; Object-oriented programming; object-oriented
                 programming; Types; types",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Lane:1991:DCA,
  author =       "A. Lane",
  title =        "{DOS\slash C++} --- application frameworks",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "7",
  pages =        "14--15",
  month =        jul # "-" # aug,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Application frameworks are object-oriented class
                 libraries that integrate user-interface building
                 blocks, fundamental data structures and support for
                 object-oriented input and output. Major components of
                 an application's interface, such as windows, pull-down
                 menus, dialog boxes, scroll bars and even a generic
                 application are modeled as classes in the hierarchy.
                 This gives programmers the ability to inherit a large
                 body of functional interface code and frees them to
                 concentrate on implementing specifics. The author looks
                 at a couple of simple examples from the forthcoming
                 Turbo Vision application framework.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6115 (Programming support); C6110 (Systems analysis
                 and programming)",
  classification = "C6110 (Systems analysis and programming); C6115
                 (Programming support)",
  keywords =     "application frameworks; Application frameworks; C
                 language; C listings; data structures; Data structures;
                 dialog boxes; Dialog boxes; functional; Functional
                 interface code; interface code; object-oriented;
                 object-oriented class libraries; Object-oriented class
                 libraries; programming; pull-down menus; Pull-down
                 menus; scroll bars; Scroll bars; software tools; Turbo
                 Vision application framework; user interfaces;
                 user-interface building blocks; User-interface building
                 blocks; windows; Windows",
  thesaurus =    "C language; C listings; Data structures;
                 Object-oriented programming; Software tools; User
                 interfaces",
  treatment =    "P Practical",
}

@Article{Brazille:1991:OIL,
  author =       "R. Brazille and B. Leggett",
  title =        "The {Object Interface Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "7",
  pages =        "18--20, 22, 24",
  month =        jul # "-" # aug,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "It is well know that object-oriented design can
                 profitably be applied to the creation of graphical user
                 interfaces. The author reviews the Object Interface
                 Library (OI), a collection of C++ classes for the X
                 Window System that offers C++ objects for common X
                 `widgets' such as scroll bars, drop-down menus, radio
                 buttons, icons, text entry fields, etc. The classes are
                 not related to the Xt widgets in any way, although they
                 do emulate some of the Intrinsics' mechanism to provide
                 better compatibility with other X tools. The most
                 interesting aspect of OI is that programs developed
                 with it are able to switch their look and feel between
                 OPEN LOOK and Motif at runtime.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6115 (Programming support); C6180 (User interfaces)",
  classification = "C6115 (Programming support); C6180 (User
                 interfaces)",
  keywords =     "Application development; application development;
                 application generators; C language; C++ classes;
                 Drop-down menus; drop-down menus; graphical; Graphical
                 user interfaces; Icons; icons; Motif; Object Interface
                 Library; object-oriented; Object-oriented design;
                 object-oriented design; OI; OPEN LOOK; programming;
                 Radio buttons; radio buttons; Scroll bars; scroll bars;
                 software tools; Text entry fields; text entry fields;
                 user interfaces; Window System; X; X Window System",
  thesaurus =    "Application generators; C language; Object-oriented
                 programming; Software tools",
  treatment =    "P Practical; R Product Review",
}

@Article{Coplien:1991:ECC,
  author =       "J. Coplien",
  title =        "Experience with {CRC} cards in {AT\&T}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "8",
  pages =        "1, 4--6",
  month =        sep,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The object paradigm is an increasingly popular way for
                 digital system developers to think about problem
                 solving. Experience has shown that the success of an
                 object-oriented design depends heavily on three
                 factors: designers' understanding of the technology,
                 creating a suitable project sociology and having people
                 with appropriate problem domain expertise. CRC cards
                 have been used in a number of AT and T software
                 projects and their use has played a role in each of
                 these factors. The author looks at each of these
                 factors in turn and the role CRC cards play to help
                 shape and enable an object-oriented development. A CRC
                 card is a 3*5 index card representing an application
                 abstraction. It lists the abstraction's class,
                 responsibilities, and collaborators. CRC cards are used
                 in interactive design sessions to flesh out the
                 identity and nature of classes when using
                 object-oriented analysis techniques. These cards are
                 filled in at meetings between key system architects,
                 designers, and customers. The cards become the
                 documentation for the initial project structure. The
                 cards may be transferred to a hypertext system for use
                 by the project at large to document system interfaces
                 and system functionality in general.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C0310F (Software
                 development management)",
  classification = "C0310F (Software development management); C6110J
                 (Object-oriented programming)",
  keywords =     "Application abstraction; application abstraction; AT
                 and T software projects; AT\&T software;
                 Class-responsibility-collaboration;
                 class-responsibility-collaboration; CRC card;
                 Customers; customers; digital; Digital system
                 developers; Documentation; documentation; human
                 factors; Index card; index card; initial project;
                 Initial project structure; Interactive design sessions;
                 interactive design sessions; key; Key system
                 architects; Object paradigm; object paradigm;
                 Object-oriented design; object-oriented design;
                 Object-oriented development; object-oriented
                 development; object-oriented programming; personnel;
                 Problem domain expertise; problem domain expertise;
                 Problem solving; problem solving; project engineering;
                 Project sociology; project sociology; projects;
                 structure; system architects; system developers; system
                 documentation; System functionality; system
                 functionality; systems analysis",
  thesaurus =    "Human factors; Object-oriented programming; Personnel;
                 Project engineering; System documentation; Systems
                 analysis",
  treatment =    "A Application; P Practical",
}

@Article{Booch:1991:OAD,
  author =       "G. Booch and M. Vilot",
  title =        "Object-oriented analysis and design",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "8",
  pages =        "7--10",
  month =        sep,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "There exist various kinds of classes useful for
                 implementing class libraries in C++, as described by B.
                 Straustrup (1991). These kinds of classes are purely a
                 design convention: nothing in the language enforces
                 their `correct' definition and use. However, settling
                 on a few standard styles can make a given library
                 clearer and more understandable. Having a common
                 vocabulary makes it easier to discuss library designs.
                 The authors look at another important vocabulary-the
                 vocabulary of the problem domain. They discuss the
                 difference between analysis and design and the role of
                 key abstractions and mechanisms in an object-oriented
                 design.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "abstractions; C language; C++; Class libraries; class
                 libraries; common; Common vocabulary; key; Key
                 abstractions; Library; library; Library designs;
                 library designs; Object-oriented design;
                 object-oriented design; object-oriented programming;
                 Problem domain; problem domain; reusability; software;
                 Standard styles; standard styles; vocabulary",
  thesaurus =    "C language; Object-oriented programming; Software
                 reusability",
  treatment =    "P Practical",
}

@Article{Cargill:1991:CCO,
  author =       "T. Cargill",
  title =        "{CRC} cards ({OO} programming)",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "8",
  pages =        "11--13",
  month =        sep,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Many newcomers to object-oriented programming have
                 difficulty `finding the objects', that is, finding
                 appropriate abstractions and capturing them as classes.
                 A low-tech, paper-and-pencil analysis and design
                 technique, known as `CRC cards', can help in the search
                 for the right classes. K. Beck, W. Cunningham (1989)
                 created CRC cards as a device for teaching
                 object-oriented programming and R. Wirfs-Brock et al.
                 (1990), have incorporated the cards into their
                 `responsibility-driven' design methodology. CRC stands
                 for class, responsibility, collaboration. The technique
                 focuses on identifying classes, assigning
                 responsibilities to classes and recording
                 collaborations between classes. Responsibilities are
                 the services that a class provides, as a server, to the
                 rest of a system. Collaboration is the interaction
                 between a client and a server-a client collaborates
                 with a server to obtain services. CRC cards encourage
                 simultaneous searches for individual classes and
                 interactions between classes.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C0310F (Software
                 development management); C6120 (File organisation)",
  classification = "C0310F (Software development management); C6110J
                 (Object-oriented programming); C6120 (File
                 organisation)",
  keywords =     "analysis; Class; class;
                 Class-responsibility-collaboration;
                 class-responsibility-collaboration; Client; client;
                 Collaboration; collaboration; CRC cards; data
                 structures; Design methodology; design methodology;
                 human factors; object-oriented programming;
                 paper-and-pencil; Paper-and-pencil analysis;
                 Responsibility-driven; responsibility-driven; Server;
                 server; Simultaneous searches; simultaneous searches;
                 systems analysis; Teaching object-oriented programming;
                 teaching object-oriented programming",
  thesaurus =    "Data structures; Human factors; Object-oriented
                 programming; Systems analysis",
  treatment =    "P Practical",
}

@Article{Booch:1991:ODP,
  author =       "G. Booch and M. Vilot",
  title =        "The object-oriented development process",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "9",
  pages =        "8--11",
  month =        oct,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Considers an important aspect of getting organized and
                 started on a project using the object-oriented
                 development approach, discussing part of the software
                 development process model. With an appropriate choice
                 of tangible design artifacts and review points, we can
                 represent the incremental and iterative OOD process in
                 linear form. The authors examine some of the software
                 project management aspects of object-oriented design.
                 They discuss some tangible design artifacts and review
                 points we can use to make the design process more
                 visible from a project planning perspective. They find
                 this helps fit a round-trip gestalt design approach
                 into management systems accustomed to a more linear
                 perspective.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C0310F (Software
                 development management)",
  classification = "C0310F (Software development management); C6110J
                 (Object-oriented programming)",
  keywords =     "analysis; Gestalt design approach; gestalt design
                 approach; Linear form; linear form; Management systems;
                 management systems; model; object-; Object-oriented
                 design; Object-oriented development; object-oriented
                 development; object-oriented programming; OOD; oriented
                 design; software development process; Software
                 development process model; software engineering;
                 Software project management; software project
                 management; systems",
  thesaurus =    "Object-oriented programming; Software engineering;
                 Systems analysis",
  treatment =    "P Practical",
}

@Article{Huneke:1991:LCC,
  author =       "I. Huneke",
  title =        "Linking {C} with {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "9",
  pages =        "12, 16",
  month =        oct,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "When developing applications in C++, the need
                 sometimes arises to call C++ functions from sections of
                 C code. This article suggests a method for providing
                 such linkage. The basic facility has been tried out
                 with Release 2.1 of cfront and with Zortech C++, so it
                 should be portable across all compilers.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming)",
  classification = "C6110 (Systems analysis and programming)",
  keywords =     "C code; C language; C listings; C++; Cfront Release
                 2.1, software portability; cfront Release 2.1, software
                 portability; Compilers; compilers; object-oriented;
                 Object-oriented programming; object-oriented
                 programming; programming; software portability; Zortech
                 C++",
  thesaurus =    "C language; C listings; Object-oriented programming;
                 Software portability",
  treatment =    "P Practical",
}

@Article{VanWyk:1991:SEY,
  author =       "C. J. {Van Wyk}",
  title =        "Simultaneous equations are your friends",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "9",
  pages =        "14--16",
  month =        oct,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Discusses how one can build a class library that
                 allows C++ programmers to express simultaneous
                 equations directly in their code. The author considers
                 nonlinear equations and complex numbers.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming); C7310
                 (Mathematics)",
  classification = "C6110 (Systems analysis and programming); C7310
                 (Mathematics)",
  keywords =     "C language; C listings; C++; Class library; class
                 library; complex numbers; Complex numbers; equations;
                 mathematics computing; nonlinear; Nonlinear equations;
                 simultaneous equations; Simultaneous equations",
  thesaurus =    "C language; C listings; Equations; Mathematics
                 computing",
  treatment =    "P Practical",
}

@Article{Coggins:1991:NCC,
  author =       "J. M. Coggins",
  title =        "Naming conventions in {C++} libraries",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "9",
  pages =        "17--21",
  month =        oct,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Follows a few threads of a long conservation about
                 naming conventions for C++, especially conventions that
                 could become part of any standard libraries
                 accompanying an ANSI/ISO standard C++ language. The
                 author's suggestions is that, in spite of being almost
                 impossible to agree on, naming conventions need to be
                 agreed upon in order to have standardized software and
                 that the exact names chosen for standard libraries and
                 classes are important to their reusability.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming)",
  classification = "C6110 (Systems analysis and programming)",
  keywords =     "ANSI/ISO standard; ANSI/ISO standard C++ language; C
                 language; C listings; C++ language; Naming conventions;
                 naming conventions; Software reusability; software
                 reusability; Standardized software; standardized
                 software",
  thesaurus =    "C language; C listings; Software reusability",
  treatment =    "P Practical",
}

@Article{LeJacq:1991:ECY,
  author =       "J. P. LeJacq",
  title =        "Education can you do better than {C++}?",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "10",
  pages =        "1, 4--6",
  month =        nov # "-" # dec,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Once an organization has made the decision to migrate
                 to C++, the obvious question arises of how to get from
                 here to there. The answer entails decisions regarding
                 languages, compilers, libraries and organization
                 changes. Certainly one of the most significant factors
                 is educating the current development team in
                 object-oriented technology. This article summarizes the
                 author's experience teaching general object-oriented
                 design courses and C++-specific courses in industrial
                 settings. He presents what seems to be an effective
                 approach and flags some potential problems.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C0220 (Education
                 and training)",
  classification = "C0220 (Education and training); C6110J
                 (Object-oriented programming)",
  keywords =     "C language; C++; Compilers; compilers; computer
                 science education; Libraries; libraries;
                 object-oriented; Object-oriented design courses;
                 object-oriented design courses; Object-oriented
                 technology; object-oriented technology; programming;
                 Teaching; teaching; training",
  thesaurus =    "C language; Computer science education;
                 Object-oriented programming; Training",
  treatment =    "P Practical",
}

@Article{Booch:1991:ODD,
  author =       "G. Booch and M. Vilot",
  title =        "Object-oriented design documents",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "10",
  pages =        "8, 10--12",
  month =        nov # "-" # dec,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Describes a possible documentation structure for a
                 project using object-oriented design. These documents
                 can be used to make the structure and status of the
                 development process more visible to the project team.
                 Of course, each project will have its own
                 considerations for recording design descriptions.
                 Project team and size and tolerance for documentation
                 are particularly influential when structuring design
                 documents.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "analysis; Documentation structure; documentation
                 structure; Object-oriented design documents;
                 object-oriented design documents; object-oriented
                 programming; process; Project team size; project team
                 size; software development; Software development
                 process; software engineering; systems",
  thesaurus =    "Object-oriented programming; Software engineering;
                 Systems analysis",
  treatment =    "P Practical",
}

@Article{Saks:1991:ACU,
  author =       "D. Saks",
  title =        "{ANSI C++} update: works in progress",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "10",
  pages =        "13--14, 16",
  month =        nov # "-" # dec,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The ANSI C++ Standards Committee X3J16 meets only
                 three times a year. Much of the Committee's work is
                 done between these meetings by small working groups
                 that clarify and evaluate issues and make proposals for
                 action by the entire committee. The active working
                 groups are C Compatibility, Core Language,
                 Environments, Extensions, Libraries, and Syntax. The
                 author discusses the work of these groups.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "ANSI; ANSI C++ Standards Committee; C Compatibility; C
                 environments; C extensions; C language; C libraries; C
                 syntax; C++ Standards Committee; Core Language;
                 object-oriented programming; standards",
  thesaurus =    "C language; Object-oriented programming; Standards",
  treatment =    "P Practical",
}

@Article{Horstmann:1991:ILB,
  author =       "C. Horstmann",
  title =        "An in-depth look as {Borland C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "10",
  pages =        "17--20",
  month =        nov # "-" # dec,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Borland C++ compiler is a product with many
                 components and features. The author looks at some of
                 the more interesting ones in greater detail. He
                 considers the support for 80*86 modes, compiler quirks,
                 the debugger, precompiled headers, VROOM overlay link
                 technique, online help and documentation, amongst other
                 features.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150C (Compilers, interpreters and other processors);
                 C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming); C6150C
                 (Compilers, interpreters and other processors)",
  keywords =     "80*86 Modes; 80*86 modes; Borland C++ compiler; C
                 language; Debugger; debugger; Documentation;
                 documentation; headers; object-oriented programming;
                 Online help; online help; Overlay link technique;
                 overlay link technique; precompiled; Precompiled
                 headers; program compilers; program debugging; software
                 packages",
  thesaurus =    "C language; Object-oriented programming; Program
                 compilers; Program debugging; Software packages",
  treatment =    "P Practical; R Product Review",
}

@Article{Coggins:1991:BCA,
  author =       "J. M. Coggins",
  title =        "Best of {\path|comp.lang.C++|} --- much ado about
                 null",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "3",
  number =       "10",
  pages =        "21--24",
  month =        nov # "-" # dec,
  year =         "1991",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Examines the different ways to represent Nothing in
                 C++. This is worthy of discussion because the
                 representation of Nothing must have a type. This
                 question eventually reaches into areas such as
                 automatic type conversion rules interactions of
                 preprocessor symbols with the type system,
                 compatibility problems among C++ implementations,
                 standardization concerns, and the interaction of
                 classes with basic types.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "Automatic type conversion rules; automatic type
                 conversion rules; C language; C listings; C++;
                 object-oriented programming; Standardization;
                 standardization",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Soukup:1992:SCL,
  author =       "J. Soukup",
  title =        "Selecting a {C++} library",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "1",
  pages =        "1, 4--6",
  month =        jan,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "There is a major difference in both the construction
                 and use of libraries in C and C++. Unless special tools
                 are available, it is difficult to code a general
                 library in C for structures such as linked lists,
                 trees, graphs, or hash tables. However, in C++, whole
                 organizations can be treated as objects, which helps in
                 library design and simplifies its use. The availability
                 of such a library speeds up development, improves code
                 quality, and greatly enhances the maintainability of
                 the software. This paper concentrates mainly on
                 general-purpose libraries that manage basic data
                 structures such as linked lists, trees, graphs, or
                 entity-relationship models. These organizations
                 typically combine several different object types
                 connected by pointers. It lists the good and bad things
                 for which one has to watch when selecting a library. It
                 also suggests a benchmark that measures both ease of
                 use and library performance.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C0310H
                 (Equipment and software evaluation methods)",
  classification = "C0310H (Equipment and software evaluation methods);
                 C6110J (Object-oriented programming)",
  keywords =     "Benchmark; benchmark; C language; C++; C++ library;
                 Code quality; code quality; Data structures; data
                 structures; Entity-relationship models;
                 entity-relationship models; Graphs; graphs; library;
                 Linked lists; linked lists; maintenance; Object types;
                 object types; Object-oriented programming;
                 object-oriented programming; Pointers; pointers;
                 software; Software maintenance; software maintenance;
                 software selection; Trees; trees",
  thesaurus =    "C language; Object-oriented programming; Software
                 maintenance; Software selection",
  treatment =    "P Practical",
}

@Article{Booch:1992:ODP,
  author =       "G. Booch and M. Vilot",
  title =        "Object-oriented design: physical design: storage
                 management",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "1",
  pages =        "7--10",
  month =        jan,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Considers the design of storage management for the
                 objects in designs. In OOD, the authors separate the
                 logical view of the classes and objects in the design
                 from the physical view of how they are packaged and
                 allocated. C++ allows us to precisely control the
                 storage management details when necessary. They
                 concentrate on one facet of physical design. Storage
                 management is an issue that faces most C++ developers.
                 One can use the features of C++ to provide convenient
                 access to the necessary details.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "C++; Classes; classes; management; Object-oriented
                 design; object-oriented design; Object-oriented
                 programming; object-oriented programming; Objects;
                 objects; storage; Storage management; systems
                 analysis",
  thesaurus =    "Object-oriented programming; Systems analysis",
  treatment =    "P Practical",
}

@Article{Saks:1992:ACU,
  author =       "D. Saks",
  title =        "{ANSI C++} update: works in progress",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "1",
  pages =        "11--14",
  month =        jan,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The ANSI C++ standards committee, X3J16, held its
                 sixth meeting in Lund, Sweden during June 1991. By
                 careful prior arrangement, the meeting coincided with
                 the first meeting for the ISO C++ working group, WG21.
                 The committees met both separately and in joint
                 session. Although much of the meeting time was spent
                 deciding how it would be best for the committees to
                 work together, there was still time for productive
                 technical discussion and a few significant decisions.
                 The author discusses the development of an
                 international standard and European representation for
                 C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages)",
  classification = "C6140D (High level languages)",
  keywords =     "ANSI C++ standards committee; C language; C listings;
                 ISO C++ working group; standards",
  thesaurus =    "C language; C listings; Standards",
  treatment =    "P Practical",
}

@Article{Horstmann:1992:OCL,
  author =       "C. Horstmann",
  title =        "The object-based class library in {Borland C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "1",
  pages =        "15--18",
  month =        jan,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Borland C++ Version 3.0 includes two class libraries,
                 principally implementing containers. The first one, the
                 so-called object-based library, is discussed. It has
                 been supplied with Borland C++ Version 2.0 and slightly
                 enhanced in the newest release. The second library is
                 new to Borland C++ 3.0 and is template based. Both
                 libraries are included in the professional version of
                 the compiler. All objects in the object-based library
                 are derived from an abstract base class Object. The
                 containers are heterogeneous and can hold any
                 collection of instances of classes derived from Object.
                 This setup is commonly known as the Smalltalk approach
                 and is used in many C++ class libraries. To test how
                 easy it is to use the library, the author modified a
                 project from a C++ training course: a simulation of
                 customers entering a bank and being serviced by an
                 array of tellers. This simulation program has a queue
                 holding customers, an array holding tellers, and a
                 priority queue holding events sorted by a time stamp.
                 Thus, there are naturally three containers in this
                 program.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "Abstract base class; abstract base class; approach;
                 Array; array; Borland C++ Version 3.0; C language; C
                 listings; Compiler; compiler; Containers; containers;
                 Events; events; Object-based class library;
                 object-based class library; object-oriented
                 programming; Priority queue; priority queue; Queue;
                 queue; Simulation; simulation; Smalltalk; Smalltalk
                 approach; Sorted; sorted; Time stamp; time stamp",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Coggins:1992:HFC,
  author =       "J. M. Coggins",
  title =        "Handling failed constructors gracefully",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "1",
  pages =        "20--22",
  month =        jan,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A constructor is a member function that is invoked
                 when an object is created. Its objective is to
                 initialize the new object to a valid state before any
                 processing occurs using the object. Some very useful
                 classes involve creating linkages with the external
                 environment-files, network connections, user
                 interfaces, processing accelerators-and the
                 construction of the object depends on certain states or
                 properties existing in that external environment. For
                 example, when we create a file object for reading, we
                 require the file name to exist. The author discusses
                 what happens if something goes wrong during
                 construction C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C listings; C++; Classes; classes;
                 Constructor; constructor; File name; file name; File
                 object; file object; Object; object; Object-oriented
                 programming; object-oriented programming",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{McCluskey:1992:ETI,
  author =       "G. McCluskey",
  title =        "An environment for template instantiation",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "1, 4--7",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The parametrized type or template feature has been
                 part of C++ for several years. Implementations of the
                 feature have started to appear in C++ compilers. An
                 interesting issue is how to handle what is known as
                 instantiation, the combining of a template with
                 arguments. The author reviews template basics, briefly
                 presents existing methods of instantiation, and then
                 describes the approach taken by one implementation (the
                 UNIX Systems Laboratories 3.0 compiler) to solve the
                 instantiation problem. What is described is an
                 environment for C++ compilation rather than part of the
                 language itself. Environment implementations are not
                 subject to standardization the way the language is and,
                 therefore, vendors are free to make different
                 implementation choices.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6150C (Compilers,
                 interpreters and other processors); C6120 (File
                 organisation)",
  classification = "C6120 (File organisation); C6140D (High level
                 languages); C6150C (Compilers, interpreters and other
                 processors)",
  keywords =     "C language; C++ compilation; C++ compilers; data
                 structures; Parametrized type; parametrized type;
                 program compilers; Template feature; template feature;
                 Template instantiation; template instantiation; UNIX
                 Systems Laboratories; Vendors; vendors",
  thesaurus =    "C language; Data structures; Program compilers",
  treatment =    "P Practical",
}

@Article{Booch:1992:PDS,
  author =       "G. Booch and M. Vilot",
  title =        "Physical design: storage and management libraries
                 ({OOP})",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "8--10",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "An examination is given of C++ storage management
                 design issues. The authors examine some common designs
                 for optimizing storage management performance and how
                 the variety of storage options influences the design of
                 class libraries. Library design is an interesting case.
                 The design of storage management in a library must
                 operate efficiently in the face of unpredictable usage
                 patterns and a variety of usage contexts. As B.
                 Stroustrup (1991) observes, `Designing a general
                 library is much harder than designing an ordinary
                 program. A program is a solution to a particular
                 problem in a particular context, but a library must be
                 the solution to a set of problems encountered in a
                 number of projects. An ordinary program can make strong
                 assumptions about its environment, but a good library
                 has to operate successfully in the contexts provided by
                 a number of programs'.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "C language; C++ storage management design issues;
                 Class libraries; class libraries; general; General
                 library; library; management performance;
                 object-oriented programming; OOP; storage; storage
                 management; Storage management performance; Storage
                 options; storage options; subroutines; Unpredictable
                 usage patterns; unpredictable usage patterns; Usage
                 contexts; usage contexts",
  thesaurus =    "C language; Object-oriented programming; Storage
                 management; Subroutines",
  treatment =    "P Practical",
}

@Article{Soukup:1992:MD,
  author =       "J. Soukup",
  title =        "Memory-resident databases",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "11--15",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A discussion is given on the use of memory-resident
                 databases developed in object-oriented C++. The method
                 was originally used by CAD designers for VLSI data. The
                 main concept is the use of memory-resident data which
                 is treated as a database. Two examples are given to
                 demonstrate the method: connectivity record for an
                 electric circuit and music collection catalogue. The
                 author explains how to implement such a database and
                 presents benchmarks to show performance.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6160 (Database management systems (DBMS)); C6140D
                 (High level languages); C6120 (File organisation);
                 C7410D (Electronic engineering); C7820 (Humanities)",
  classification = "C6120 (File organisation); C6140D (High level
                 languages); C6160 (Database management systems (DBMS));
                 C7410D (Electronic engineering); C7820 (Humanities)",
  keywords =     "Benchmarks; benchmarks; C language; CAD; CAD
                 designers; circuit CAD; connectivity; Connectivity
                 record; database management systems; designers;
                 Electric circuit; electric circuit; Memory-resident
                 data; memory-resident data; Memory-resident databases;
                 memory-resident databases; music; Music collection
                 catalogue; music collection catalogue; Object-oriented
                 C++; object-oriented C++; record; storage management;
                 VLSI data",
  thesaurus =    "C language; Circuit CAD; Database management systems;
                 Music; Storage management",
  treatment =    "P Practical",
}

@Article{Skelly:1992:GHN,
  author =       "C. Skelly",
  title =        "Getting a handle on the new-handler",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "16--18",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A problem in moving from a C development environment
                 to a C++ environment is that C++ constructors don't
                 return anything. How can we know whether a constructor
                 has succeeded or failed if constructors never return an
                 indicating value? Is there a way to determine if the
                 memory allocation has occurred successfully despite the
                 silence of tight-lipped C++ constructors? In fact, such
                 a method does exist. It is built into the language to
                 handle just such an exigency. A predefined function
                 pointer, called the -new-handler, can be set by users
                 to point to a user-defined routine, which will be
                 executed if ever the new operator should have the
                 temerity or ill fortune to fail. This user-defined
                 routine can perform any action it pleases, including
                 setting an error flag, attempting to recover memory,
                 exiting, aborting, or, in state-of-the-art C++
                 environments, throwing an exception. In fact, the
                 -new-handler is a built-in exception handler packaged
                 for ease of use.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation); C6150J
                 (Operating systems)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages); C6150J
                 (Operating systems)",
  keywords =     "C development environment; C language; C++; C++
                 constructors; C++ environment; constructors; data
                 structures; Error flag; error flag; Exception;
                 exception; Exception handler; exception handler; Memory
                 allocation; memory allocation; object-oriented
                 programming; pointer; predefined function; Predefined
                 function pointer; storage allocation; User-defined
                 routine; user-defined routine",
  thesaurus =    "C language; Data structures; Object-oriented
                 programming; Storage allocation",
  treatment =    "P Practical",
}

@Article{Coggins:1992:AQA,
  author =       "J. M. Coggins",
  title =        "An array of questions about arrays",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "19--22",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Arrays of objects in C++ raise important issues for
                 language designers and users alike. The issues include
                 how to initialize the array elements, how to ensure
                 that the array is properly deallocated, how to return
                 an array as the result of a function, how to pass
                 arrays as arguments without copying the array, how to
                 make sure that an array passed as an argument will not
                 be changed by the called procedure, how to define
                 operator=() for a class containing an array, and so on.
                 Several of these issues have arisen in net
                 conversation, and a few of them are summarized.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., North Carolina Univ., Chapel
                 Hill, NC, USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  corpsource =   "Dept. of Comput. Sci., North Carolina Univ., Chapel
                 Hill, NC, USA",
  keywords =     "Arguments; arguments; Array elements; array elements;
                 C language; data structures; Deallocated; deallocated;
                 Function; function; Language designers; language
                 designers; object-oriented programming; Users; users",
  thesaurus =    "C language; Data structures; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Hamsath:1992:ZCD,
  author =       "N. Hamsath",
  title =        "{Zortech C++ Developers Edition}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "2",
  pages =        "23--25",
  month =        feb,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Developers Edition of Zortech's product, as
                 reviewed, is an upgrade of the first PC-based AT and T
                 V2.0 compliant C++ compiler. It requires an IBM PC, XT,
                 AT, 3/486, or compatible computer, MS-DOS/PC-DOS v3.0
                 or above, and at least 640 Kb of RAM. As installed, the
                 total size of the eight-disk DOS version with all
                 options is about 18 Mb. The disks are in archive form
                 and can be installed as a unit or installed separately,
                 as needed. Also, the disks can be read in any order.
                 Although it does not take long to reload files (if
                 necessary after the first installation) from the disk,
                 it is still a chore. Zortech C++V3.0el (ztc) is a C++
                 and a C compiler (source-level compatible with
                 Microsoft) with a completely integrated development
                 environment that supports almost any monitor.",
  acknowledgement = ack-nhfb,
  affiliation =  "Nat. Inst. of Health, Bethesda, MD, USA",
  classcodes =   "C6150C (Compilers, interpreters and other processors);
                 C6140D (High level languages)",
  classification = "C6140D (High level languages); C6150C (Compilers,
                 interpreters and other processors)",
  corpsource =   "Nat. Inst. of Health, Bethesda, MD, USA",
  keywords =     "640 Kbytes; C compiler; C language; C++ compiler;
                 Developers Edition; DOS/PC-DOS; IBM computers; IBM PC;
                 Integrated development environment; integrated
                 development environment; microcomputer applications;
                 Microsoft; MS-; MS-DOS/PC-DOS; PC-based AT and T;
                 PC-based AT\&T; program compilers; software packages;
                 Source-level compatible; source-level compatible",
  numericalindex = "Memory size 6.6E+05 Byte",
  thesaurus =    "C language; IBM computers; Microcomputer applications;
                 Program compilers; Software packages",
  treatment =    "P Practical; R Product Review",
}

@Article{Stroustrup:1992:RTI,
  author =       "B. Stroustrup and D. Lenkov",
  title =        "Runtime type identification for {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "3",
  pages =        "32--42",
  month =        mar # "-" # apr,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A proposal is described for a mechanism for runtime
                 type identification and checked type casts, which is
                 simple to use, easy to implement, and extensible. This
                 proposal evolved through a series of earlier proposals
                 and ideas, and experimental implementations exist.
                 However this proposal and the features described may
                 never be accepted into C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6120 (File
                 organisation)",
  classification = "C6120 (File organisation); C6140D (High level
                 languages)",
  keywords =     "C language; C++; Checked type casts; checked type
                 casts; data structures; Experimental implementations;
                 experimental implementations; Runtime type
                 identification; runtime type identification",
  thesaurus =    "C language; Data structures",
  treatment =    "P Practical",
}

@Article{Dewhurst:1992:DAI,
  author =       "S. C. Dewhurst",
  title =        "Distributed abstract interfaces",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "3",
  pages =        "44--50",
  month =        mar # "-" # apr,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In C++, an abstract data type (ADT) and its class
                 implementation are often viewed as equivalent. This is
                 a useful simplification for many ADTs in those cases
                 where the abstract operations of the type can be
                 represented cleanly in the public (or public and
                 protected) regions of a single class declaration.
                 However, not all ADTs are so simple. The author shows
                 why it is often convenient to distribute the abstract
                 interface of an ADT among a set of C++ classes. The
                 usual one-to-one mapping of ADT to class can be viewed
                 as a degenerate form of this more general case. The
                 discussion is motivated largely by the problems
                 associated with performing (abstract) traversals of
                 ADTs that have (abstract) structure. An extended
                 discussion of the techniques of control abstraction is
                 given.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "Abstract data type; abstract data type; Abstract
                 operations; abstract operations; abstraction; ADT; C
                 language; C++ classes; class; Class implementation;
                 control; Control abstraction; data structures;
                 declaration; Distributed abstract interfaces;
                 distributed abstract interfaces; implementation;
                 object-oriented programming; One-to-one mapping;
                 one-to-one mapping; single class; Single class
                 declaration",
  thesaurus =    "C language; Data structures; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Musser:1992:ESC,
  author =       "J. Musser",
  title =        "Extending streambufs: class logstrbuf ({OOP})",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "3",
  pages =        "51--55",
  month =        mar # "-" # apr,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "It is often desirable to encapsulate a set of existing
                 operating system services in an object-oriented fashion
                 to streamline their use within an application. C++
                 provides the necessary tools for developers, including
                 those not involved in creating operating systems, to
                 encapsulate and possibly extend a variety of operating
                 system services. A solid foundation for many such
                 services is provided by the iostream library. The
                 author describes the design of the logstrbuf class,
                 which was developed to encapsulate the Berkeley Unix
                 syslog facility. This class is derived from streambuf,
                 the underlying buffering layer of the iostreams
                 library. The techniques used can similarly be applied
                 to other I/O and IPC operations, including sockets,
                 shared memory, window system IPC and the like. This
                 example shows how the streambuf class can be used to
                 achieve powerful results when applied to specific
                 problem domains.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation); C6150J
                 (Operating systems)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages); C6150J
                 (Operating systems)",
  keywords =     "Berkeley Unix syslog; Berkeley Unix syslog facility; C
                 language; C++; data structures; facility; I/O;
                 input-output programs; Iostream library; iostream
                 library; IPC; IPC operations; Logstrbuf class;
                 logstrbuf class; object-; Object-oriented fashion;
                 object-oriented fashion; Operating system services;
                 operating system services; operations; oriented
                 programming; Shared memory; shared memory; Sockets;
                 sockets; Streambuf; streambuf; Underlying buffering
                 layer; underlying buffering layer; Window system IPC;
                 window system IPC",
  thesaurus =    "C language; Data structures; Input-output programs;
                 Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Buroff:1992:CO,
  author =       "S. Buroff and R. Murray",
  title =        "The {C++} Oracle",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "9--10",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The authors are concerned with the following
                 questions: If they use a template class and only call
                 for a few of its member functions, are all member
                 functions instantiated or only those they call? The
                 first thing to understand about this question is that
                 its answer is not part of the definition of C++.
                 Instead, this is left as a quality of implementation
                 issue. A C++ compiler is free to instantiate all member
                 functions or only those referenced without being in
                 violation of the standard. They term the instantiation
                 of only the referenced member functions selective
                 instantiation.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C listings; C++; Compiler; compiler;
                 functions; member; Member functions; Object-oriented
                 programming; object-oriented programming; Selective
                 instantiation; selective instantiation; Template class;
                 template class",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Eckel:1992:VC,
  author =       "B. Eckel",
  title =        "Virtual constructors. 2",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "13--16",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "For pt.1, see ibid., vol.4, no.3, p.13-18 (1992). This
                 paper concludes the presentation of the concept of
                 virtual constructors. It talks about destructors and
                 virtual destructor operation when using virtual
                 constructors and then goes on to discuss code
                 formatting.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C listings; C++ language; Code formatting;
                 code formatting; constructors; Destructors;
                 destructors; Object-oriented programming;
                 object-oriented programming; virtual; Virtual
                 constructors; Virtual destructor operation; virtual
                 destructor operation",
  thesaurus =    "C language; C listings; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Booch:1992:LDS,
  author =       "G. Booch and M. Vilot",
  title =        "Logical design: software component libraries",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "18, 20--22",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Considers some of the issues in designing a library of
                 reusable software components. Such libraries can be
                 used to help improve productivity in software
                 development by providing prefabricated, pretested
                 parts. One can build applications by assembling and
                 customizing these elements, rather than redeveloping
                 them for each application. When one models the key
                 abstractions of a problem domain, the resulting classes
                 tend to be reusable across the set of applications
                 built for that domain. One could organize these classes
                 into a library of reusable components. Existing C++
                 libraries each focus on specific domains.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  keywords =     "C language; C++; Key abstractions; key abstractions;
                 Object-oriented design; object-oriented design;
                 object-oriented programming; reusability; Reusable
                 software; reusable software; software; Software
                 component libraries; software component libraries;
                 Software development; software development",
  thesaurus =    "C language; Object-oriented programming; Software
                 reusability",
  treatment =    "P Practical",
}

@Article{Skelly:1992:LO,
  author =       "C. Skelly",
  title =        "In the land of {OOP}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "23--26",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author begins an ongoing adventure into some of
                 the wilder forest regions, along some of the lesser
                 known paths, that run through the land of
                 object-oriented programming and C++. He imagines a
                 generic situation in which a datastream, composed of
                 packets of information, is being received by a
                 processing component of some sort. One option for
                 handling such a stream in C++ is to instantiate a
                 `handling object' for every data packet received.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "C language; C++; Data packet; data packet;
                 Object-oriented programming; object-oriented
                 programming",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Soukup:1992:BTC,
  author =       "J. Soukup",
  title =        "Beyond templates. 1. ({C++})",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "27--31",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The good news is that C++ compilers are beginning to
                 support templates. The bad news is that templates do
                 not do what they were invented for very well. The main
                 purpose of templates is to provide a mechanism for
                 building general data structures such as linked lists,
                 trees, and graphs without giving up the protection of
                 full static typing. Data structures involve pointer
                 relations between different types of objects and are,
                 in the realm of object-oriented programming, often
                 referred to as associations and aggregations. The
                 author looks at the following approaches to building
                 data structures: templates and indirect links;
                 templates combined with multiple inheritance; templates
                 inheritance, and a code generator; and class generator
                 only. He particularly covers the first approach in this
                 issue. He stretches the use of templates to its limits
                 and uses new ideas and nonstandard approaches.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6150C
                 (Compilers, interpreters and other processors)",
  classification = "C6110J (Object-oriented programming); C6150C
                 (Compilers, interpreters and other processors)",
  keywords =     "Aggregations; aggregations; Associations;
                 associations; C language; C++ compilers; Class
                 generator; class generator; Code generator; code
                 generator; Data structures; data structures; Full
                 static typing; full static typing; Graphs; graphs;
                 indirect; Indirect links; Inheritance; inheritance;
                 Linked lists; linked lists; links; object-;
                 Object-oriented programming; object-oriented
                 programming; oriented programming; Pointer relations;
                 pointer relations; program compilers; Templates;
                 templates; Trees; trees",
  thesaurus =    "C language; Data structures; Object-oriented
                 programming; Program compilers",
  treatment =    "P Practical",
}

@Article{Horstmann:1992:MCC,
  author =       "G. Horstmann",
  title =        "The {Microsoft C\slash C++ Version 7} compiler: {A}
                 first impression",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "53--57",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author discusses the Microsoft C/C++ Version 7
                 compiler. In terms of sales, Borland is clearly the
                 biggest player in this market. The Microsoft press kit
                 contains a large number of feature comparisons with
                 Borland, without mentioning any other vendors at all.
                 He discusses some of the Microsoft sales arguments, as
                 well as some other comparisons that the Microsoft
                 marketing staff wisely omitted from the press kit.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150C (Compilers, interpreters and other
                 processors)",
  classification = "C6150C (Compilers, interpreters and other
                 processors)",
  keywords =     "Borland; C language; Compiler; compiler; Marketing;
                 marketing; Microsoft C/C++ Version 7; program
                 compilers",
  thesaurus =    "C language; Program compilers",
  treatment =    "P Practical; R Product Review",
}

@Article{Coggins:1992:QCW,
  author =       "J. M. Coggins",
  title =        "Questioning conventional `wisdom' about {C++} code
                 size and execution speed",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "4",
  pages =        "58--61",
  month =        may,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Object-oriented design and programming affect how
                 people think about computer programming and how people
                 think through computer programming problems.
                 Eventually, however, it is necessary to get down to
                 pragmatic concerns such as lines of code and speed of
                 program development and execution. This column surveys
                 a few of the more enlightening network postings
                 concerned with evaluations of the pragmatics of C++.
                 Such evaluations cannot be conducted effectively
                 without care for definitions of terms and experimental
                 controls that is rarely exercised in informal
                 conversations on the network. First, it considers the
                 pragmatic concern of source program length.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++; C++ code size; code size; Execution
                 speed; execution speed; Object-oriented design;
                 object-oriented design; Object-oriented programming;
                 object-oriented programming; Program development;
                 program development",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Wilkinson:1992:SCO,
  author =       "N. M. Wilkinson",
  title =        "Subtleties of {C++} operator overloading",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "5",
  pages =        "36--41",
  month =        jun,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In C++, a programmer uses the class construct to
                 create data types that mimic, to a great extent, the
                 look and behavior of built-in types. As with a built-in
                 type, the representation of the class can be hidden
                 from the user and accessed only through operations
                 defined on the type. Also, the construction and
                 destruction of objects of the user-defined data type
                 are handled automatically. Conversions, which are often
                 invisibly applied, can be defined by the class to and
                 from other types. Additionally, the C++ class author
                 may define functions for the class that represent
                 operators to be applied to that type. Many C++ users
                 think that these forms are equivalent, but they are
                 not. And the subtlety of the difference can take an
                 unsuspecting programmer by surprise. This article
                 examines a number of the subtle points in declaring and
                 using overloaded operators in C++. These points will
                 also illustrate exactly what the compiler will do, and
                 will not do, to resolve an operator expression.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  keywords =     "built-in; Built-in types; C language; C++; Compiler;
                 compiler; Data types; data types; Object-oriented
                 programming; object-oriented programming; Overloaded
                 operators; overloaded operators; program compilers;
                 types",
  thesaurus =    "C language; Object-oriented programming; Program
                 compilers",
  treatment =    "P Practical",
}

@Article{Strickland:1992:ODD,
  author =       "H. Strickland",
  title =        "Object databases: a deep look at transparency",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "5",
  pages =        "42--46",
  month =        jun,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "When some people speak of transparency, they mean
                 `surface transparency', or `automaticness'. Surface
                 transparency measures how well something automatically
                 happens when compiled, unaltered, by a certain product,
                 or how much you have to do to make something
                 automatically happen. As a start, surface transparency
                 is a good measure and a respectable goal, and it may
                 help to get a demo running in a weekend. For a serious
                 software development project, deeper measures of
                 transparency are far more important. This article will
                 point out some of the issues that need to be addressed
                 in evaluating `deep transparency'. It presents some
                 sample interfaces to discuss transparency with
                 examples. These examples will address several important
                 concepts that object databases bring to C++. Three of
                 these are extended object lifetime, expanded object
                 identity, and automatic maintenance bidirectional
                 (inverse) relationships.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6160J (Object-oriented databases); C6110J
                 (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming); C6160J
                 (Object-oriented databases)",
  keywords =     "Automatic maintenance bidirectional relationships;
                 automatic maintenance bidirectional relationships; C
                 language; C++; expanded; Expanded object identity;
                 Extended object lifetime; extended object lifetime;
                 Interfaces; interfaces; Object databases; object
                 databases; object identity; object-oriented;
                 object-oriented databases; programming; Software
                 development project; software development project;
                 Transparency; transparency",
  thesaurus =    "C language; Object-oriented databases; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Cargill:1992:DVH,
  author =       "T. Cargill",
  title =        "A dynamic vector is harder than it looks",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "5",
  pages =        "47--50",
  month =        jun,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "There is a subtle bug in the vector template in Glen
                 McCluskey's article on template instantiation that
                 should be brought to the attention of programmers who
                 are considering building a similar class template, see
                 ibid., vol.4, no.2, p.1-7 (1992). The bug arises from
                 dangling references, which may appear in a variety of
                 circumstances. Exactly which expressions in client code
                 will produce dangling references depends upon the order
                 of expression evaluation, which, in general, is not
                 well defined.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "C language; C++; Dangling references; dangling
                 references; Dynamic vector; dynamic vector;
                 instantiation; object-oriented programming; programming
                 theory; template; Template instantiation; Vector
                 template; vector template",
  thesaurus =    "C language; Object-oriented programming; Programming
                 theory",
  treatment =    "P Practical",
}

@Article{Leggett:1992:UCS,
  author =       "B. Leggett",
  title =        "The {USL C++} Standard Components release 2 (end
                 user package)",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "5",
  pages =        "69--73",
  month =        jun,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Release 2 of the UNIX System Laboratories (USL),
                 Standard Components (SC) is the end product in a
                 continuing development of C++ class libraries that has
                 been going on inside AT and T Bell Labs and USL for
                 several years. These classes have evolved with the C++
                 language and its capabilities. They present a robust,
                 well-tested set of collection, array, and string
                 classes that are useful in almost any C++ program or
                 application of any complexity.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "Array classes; array classes; AT and T Bell Labs;
                 AT\&T Bell Labs; C language; C++ class; C++ class
                 libraries; Collection classes; collection classes; End
                 user package; end user package; libraries;
                 object-oriented programming; software tools; Standard
                 Components release 2; String classes; string classes;
                 UNIX System Laboratories",
  thesaurus =    "C language; Object-oriented programming; Software
                 tools",
  treatment =    "P Practical; R Product Review",
}

@Article{Meyers:1992:UCE,
  author =       "S. Meyers",
  title =        "Using {C++} effectively. Approaches to effectiveness",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "6",
  pages =        "34--39",
  month =        jul # "-" # aug,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "As the community of C++ programmers matures, there is
                 a natural shift from interest in what the language
                 features are to how to effectively use them. Guidelines
                 for class interfaces serve as useful starting points
                 for discussion, but they are hampered by the rich
                 variety of settings in which C++ is employed.
                 Constraint-checking programs modeled on lint offer the
                 advantage of automated detection of constraint
                 violations, but still suffer from the difficulty in
                 coming up with constraints that are universally
                 applicable. Natural language guidelines such as those
                 found in EFFECTIVE C++ are a good way to initiate C++
                 programmers into the subtleties of the language, but
                 such guidelines are rarely amenable to automatic
                 enforcement. Finally, a constraint language like CCEL
                 vastly expands the expressiveness and flexibility of an
                 automatic constraint-checking program, but it cannot
                 overcome the fact that many useful heuristics for C++
                 software development are impossible to formalize. The
                 search for better ways to summarize how to use C++
                 effectively will continue, of course, but for the
                 foreseeable future, the best approach is a combination
                 of informal guidelines with well-defined areas of
                 applicability, increasingly sophisticated automated
                 tools, and the insights that can only be gleaned from
                 bitter experience.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., Brown Univ., Providence, RI,
                 USA",
  classcodes =   "C6140D (High level languages)",
  classification = "C6140D (High level languages)",
  corpsource =   "Dept. of Comput. Sci., Brown Univ., Providence, RI,
                 USA",
  keywords =     "Automated tools; automated tools; C language; C++;
                 CCEL; class; Class interfaces; Constraint checking
                 programs; constraint checking programs; Constraint
                 language; constraint language; Constraint violations;
                 constraint violations; Expressiveness; expressiveness;
                 interfaces; Programmers; programmers",
  thesaurus =    "C language",
  treatment =    "P Practical",
}

@Article{Tavakkolian:1992:CPP,
  author =       "S. Tavakkolian",
  title =        "Crossing paradigms. {A} pilgrim's journey from {C} to
                 {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "6",
  pages =        "40--45",
  month =        jul # "-" # aug,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Changing from C and procedural programming to C++ and
                 object-oriented (O-O) programming can be a hard
                 proposition. The author looks at the problem, it is not
                 just a matter of learning rules for spelling and
                 syntax, it is learning a completely new way of
                 expressing thoughts.",
  acknowledgement = ack-nhfb,
  affiliation =  "Claircom, Seattle, WA, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Claircom, Seattle, WA, USA",
  keywords =     "C; C language; C++; object-oriented programming; OO
                 programming; Procedural programming; procedural
                 programming",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Martin:1992:ACP,
  author =       "R. Martin",
  title =        "Abstract classes and pure virtual functions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "6",
  pages =        "46--52",
  month =        jul # "-" # aug,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Abstract classes provide a powerful design technique
                 which promotes code reuse and polymorphism. Abstract
                 classes are produced by factoring out the common
                 features of the concrete classes of the application.
                 Although such factorings are sometimes hard to find,
                 the effort put into finding them is usually well worth
                 the benefits of the extra maintainability and
                 reusability. In general, common features should be
                 factored out and moved as high as possible in the
                 inheritance structure. In C++, pure virtual functions
                 are used to specify the pure interfaces of abstract
                 classes. An abstract class in C++ must have at least
                 one pure virtual function. Although pure virtual
                 functions typically have no implementation, C++ allows
                 implementations to be given to them. The user must take
                 care not to invoke pure virtual functions in the
                 constructors or destructors of an abstract class.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "Abstract classes; abstract classes; C language; C++;
                 Maintainability; maintainability; object-oriented
                 programming; Pure virtual functions; pure virtual
                 functions; Reusability; reusability",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Ball:1992:ITI,
  author =       "M. Ball",
  title =        "Inside templates: implementing {C++} strategies",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "7",
  pages =        "36--40",
  month =        sep,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The authors outline the framework of their mythical
                 C++ compiler. They then consider some embellishments
                 that can be added and describe the construction of
                 token streams. The token stream is a good example of a
                 tool that can be used in several (sometimes unexpected)
                 places in a C++ compiler. In fact, the entire token
                 stream mechanism was developed for use in parsing, and
                 has proved to have further application when
                 implementing inline functions, class definitions and
                 now, templates. It's also a good example of code that
                 developed from an ad hoc technique for handling a
                 difficult problem (parser lookahead and backtracking)
                 into a clean and powerful technique with general
                 applicability.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150C (Compilers, interpreters and other processors);
                 C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  keywords =     "Ad hoc technique; ad hoc technique; Backtracking;
                 backtracking; C language; C++ compiler; Class
                 definitions; class definitions; functions; inline;
                 Inline functions; lookahead; object-oriented
                 programming; parser; Parser lookahead; Parsing;
                 parsing; program compilers; program processors;
                 Templates; templates; Token stream; token stream",
  thesaurus =    "C language; Object-oriented programming; Program
                 compilers; Program processors",
  treatment =    "P Practical",
}

@Article{Becker:1992:MCS,
  author =       "P. Becker",
  title =        "A msgstream class for smart formatting: Easing the
                 translator's job",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "7",
  pages =        "42--48",
  month =        sep,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author briefly summarizes the problems that come
                 up during translation of program into a different
                 national language, and describes a variation of the
                 class ostream that solves one of the biggest ones. The
                 author discusses text translation, collating sequences;
                 character sets; and string lengths. He introduces the
                 msgstream class and the msgbuf class. He provides a C
                 listing for msgbuf. National language support must be
                 designed into programs. Put all your text strings into
                 resources or at least a separate source file. Use
                 strcoll(), not strcmp(). Use wide chars. Don't
                 hard-code buffer sizes, and be sure that all buffers
                 are big enough to allow for growth during translation.
                 Use flexible formatting techniques. In short, think
                 about the problems of translating the program for use
                 with a different language before starting to write the
                 code. This will make the translator's job much
                 easier.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110 (Systems analysis and programming); C6110J
                 (Object-oriented programming)",
  classification = "C6110 (Systems analysis and programming); C6110J
                 (Object-oriented programming)",
  keywords =     "C listing; C listings; Character sets; character sets;
                 collating; Collating sequences; data structures;
                 flexible; Flexible formatting techniques; formatting
                 techniques; input-output programs; National language;
                 national language; object-; oriented programming;
                 Ostream; ostream; programming; sequences; Strcmp();
                 strcmp(); Strcoll(); strcoll(); String lengths; string
                 lengths; strings; system documentation; text; Text
                 strings; Text translation; text translation; Wide
                 chars; wide chars",
  thesaurus =    "C listings; Data structures; Input-output programs;
                 Object-oriented programming; Programming; System
                 documentation",
  treatment =    "P Practical",
}

@Article{Bartels:1992:POO,
  author =       "D. Bartels and J. Robie",
  title =        "Persistent objects and object-oriented databases for
                 {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "7",
  pages =        "49--50, 52--56",
  month =        sep,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "To store data in a conventional database, it must be
                 dissected into a series of two-dimensional tables. Only
                 predeclared data types are supported. Object-oriented
                 programming languages have a rich set of features for
                 creating data types and representing the relationships
                 among data that are not supported in such databases.
                 The authors discuss features that an object-oriented
                 database must support. To illustrate these features we
                 examine POET, a commercial object-oriented database
                 system with which the authors are connected.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6160J (Object-oriented databases); C6120 (File
                 organisation)C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6160J (Object-oriented databases)",
  keywords =     "C language; C listings; Data types; data types;
                 Object-oriented database; object-oriented database;
                 object-oriented databases; POET",
  thesaurus =    "C language; C listings; Object-oriented databases",
  treatment =    "P Practical",
}

@Article{Carroll:1992:IIM,
  author =       "M. Carroll",
  title =        "Invasive inheritance: modifying a base class to enable
                 inheritance",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "8",
  pages =        "34--42",
  month =        oct,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author calls the act of modifying the intended
                 base class, then inheriting from it invasive
                 inheritance. He shows an example of invasive
                 inheritance in C++. The intended base class represents
                 the set of binary search trees; the intended derived
                 class represents the set of red-black trees. A
                 red-black tree IS-A binary search tree. He shows a
                 typical implementation of a binary search tree class.
                 Then he shows that attempting to derive a red-black
                 tree class from the binary search tree class fails, and
                 what invasions into the base class one must make to
                 permit the derivation to work. The invasive inheritance
                 problem is not unique to C++. He explains what
                 properties programming languages in general have that
                 cause the need for such an invasion. Most of the causes
                 of invasive inheritance could theoretically be removed
                 from programming languages, but only at the cost of
                 introducing other problems.",
  acknowledgement = ack-nhfb,
  affiliation =  "AT and T Bell Labs., Murray Hill, NJ, USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "AT\&T Bell Labs., Murray Hill, NJ, USA",
  keywords =     "Binary search tree; binary search tree; C language;
                 C++; Inheritance; inheritance; Intended base class;
                 intended base class; Invasive inheritance; invasive
                 inheritance; object-oriented programming; Red-black
                 trees; red-black trees",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Banahan:1992:CTM,
  author =       "M. Banahan",
  title =        "Cross-over training: making the transition from {C} to
                 {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "8",
  pages =        "44--48",
  month =        oct,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author has been teaching C programmers to make the
                 transition to C++ for nearly seven years. Merely
                 teaching syntax is not enough. Doing so leaves students
                 knowing how, but not why. Managers are often unhappy at
                 the end of the process because nobody told them that
                 they were changing to a very different style of
                 programming, let alone to a language that is at least
                 as complex as Ada. The article describes ways found to
                 produce happiness in the first group, while allaying
                 fears of the second (to some extent).",
  acknowledgement = ack-nhfb,
  classcodes =   "C0220 (Education and training); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  classification = "C0220 (Education and training); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  keywords =     "C language; computer science education;
                 object-oriented; programming; Training; training",
  thesaurus =    "C language; Computer science education;
                 Object-oriented programming; Training",
  treatment =    "A Application; P Practical",
}

@Article{Schmidt:1992:SPC,
  author =       "D. Schmidt",
  title =        "Systems programming with {C++} wrappers: encapsulating
                 {IPC} services with object-oriented interfaces",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "4",
  number =       "8",
  pages =        "50--54",
  month =        oct,
  year =         "1992",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The article describes a technique for encapsulating
                 existing operating system interprocess communication
                 (IPC) services within object-oriented C++ wrappers.
                 These services include mechanisms for local IPC (such
                 as shared memory; semaphores; message queues;
                 memory-mapped files; named, unnamed, and stream pipes;
                 and BSD UNIX-domain sockets) and network IPC (such as
                 remote procedure calls (RPC), BSD Internet-domain
                 sockets, and System V Transport Layer Interface
                 (TLI)).",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6150N
                 (Distributed systems)",
  keywords =     "BSD; BSD Internet-domain sockets; BSD UNIX-domain
                 sockets; C++ wrappers; Interface; interprocess
                 communication; IPC services; Local IPC; local IPC;
                 memory; Memory-mapped files; memory-mapped files;
                 Message queues; message queues; Network IPC; network
                 IPC; network operating systems; Object-oriented
                 interfaces; object-oriented interfaces; object-oriented
                 programming; operating system; Operating system
                 interprocess communication; Remote procedure calls;
                 remote procedure calls; Semaphores; semaphores; shared;
                 Shared memory; System V Transport Layer; System V
                 Transport Layer Interface; Unix; UNIX-domain sockets",
  thesaurus =    "Network operating systems; Object-oriented
                 programming; Unix",
  treatment =    "P Practical",
}

@Article{Meyers:1993:UCE,
  author =       "S. Meyers",
  title =        "Using {C++} effectively. Examining development tools",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "1",
  pages =        "30, 32--35",
  month =        jan,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Discusses some questions you might want to direct at
                 vendors of debuggers, class browsers, and development
                 environments. Choosing effective tools for C++ software
                 development is not as easy as it should be, although
                 the situation is substantially better than it was. Arm
                 yourself with as much information about your
                 programming needs as you possibly can, because until
                 high-quality tools for C++ development become widely
                 available on all platforms, the best advice remains
                 unchanged from that of centuries ago: caveat emptor
                 (let the buyer beware).",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., Brown Univ., Providence, RI,
                 USA",
  classcodes =   "C6115 (Programming support); C0310H (Equipment and
                 software evaluation methods); C6150G (Diagnostic,
                 testing, debugging and evaluating systems); C6110J
                 (Object-oriented programming)",
  classification = "C0310H (Equipment and software evaluation methods);
                 C6110J (Object-oriented programming); C6115
                 (Programming support); C6150G (Diagnostic, testing,
                 debugging and evaluating systems)",
  corpsource =   "Dept. of Comput. Sci., Brown Univ., Providence, RI,
                 USA",
  keywords =     "browsers; C language; C++ software development tool
                 selection; class; Class browsers; Debuggers; debuggers;
                 Development environments; development environments;
                 object-oriented languages; program debugging;
                 programming environments; Programming needs;
                 programming needs; software selection; software tools",
  thesaurus =    "C language; Object-oriented languages; Program
                 debugging; Programming environments; Software
                 selection; Software tools",
  treatment =    "P Practical",
}

@Article{Reed:1993:ETC,
  author =       "D. Reed",
  title =        "Engineering the transition to {C++}: a manager's
                 perspective on realizing the benefits of {OOP}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "1",
  pages =        "36, 38--42",
  month =        jan,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Managing the transition from C to C++ necessitates
                 good engineering. As with any engineering task, the
                 trade-offs must be understood and evaluated. This
                 article provides a realistic view of the trade-offs
                 associated with moving to C++ and object-oriented
                 programming (OOP). Moving to the language is definitely
                 a good idea, and it can be done incrementally. If the
                 incremental approach is taken, the benefits are
                 received incrementally as well.",
  acknowledgement = ack-nhfb,
  classcodes =   "C0310F (Software development management); C6140D (High
                 level languages); C6110J (Object-oriented
                 programming)",
  classification = "C0310F (Software development management); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  keywords =     "C language; C++; DP management; Incremental approach;
                 incremental approach; Language migration; language
                 migration; Manager's perspective; manager's
                 perspective; object-; object-oriented languages;
                 Object-oriented programming; object-oriented
                 programming; oriented programming; Trade-offs;
                 trade-offs",
  thesaurus =    "C language; DP management; Object-oriented languages;
                 Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Vines:1993:SRT,
  author =       "D. Vines and Z. Kishimoto",
  title =        "{Smalltalk}'s runtime type support for {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "1",
  pages =        "44--52",
  month =        jan,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Object Management Group (OMG) is establishing
                 specifications for a common framework for integrating
                 distributed applications using an object technology
                 approach. One of these specifications is the Common
                 Object Request Broker Architecture (CORBA). It defines
                 the mechanisms required to transparently apply requests
                 to objects and receive responses over a network. These
                 mechanisms are implemented by an object request broker
                 (ORB) and enable different applications running on
                 different machine to `inter-operate' with each other.
                 All of ORB's functions require access to type
                 information at runtime. To support these features,
                 runtime type information needs to include: type of
                 object, methods of type, inheritance of types, identity
                 of object and type, and instances of type. Smalltalk
                 supports all these features as part of the language
                 system, except for the passing of objects across
                 address spaces. Therefore, instead of developing a new
                 method, the authors decided to emulate Smalltalk typing
                 with C++ and to do it in such a way as not to require
                 any changes to the language itself or existing
                 compilers.",
  acknowledgement = ack-nhfb,
  affiliation =  "NEC C and C Software Technol. Center, Irvine, TX,
                 USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "NEC C and C Software Technol. Center, Irvine, TX,
                 USA",
  keywords =     "abstract data types; Architecture; C language; C++;
                 Common Object Request Broker; Common Object Request
                 Broker Architecture; CORBA; Interoperating
                 applications; interoperating applications; Network;
                 network; Object Management Group; Runtime type support;
                 runtime type support; Smalltalk",
  thesaurus =    "Abstract data types; C language; Smalltalk",
  treatment =    "P Practical",
}

@Article{Coggins:1993:PPL,
  author =       "J. M. Coggins",
  title =        "Practical principles for library design. {I}.
                 Selecting the right abstractions is the key",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "2",
  pages =        "38--42",
  month =        feb,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Image processing and analysis presents several design
                 and programming challenges that exercise the nuances of
                 both object-oriented design and C++. The article is the
                 first in a series that discusses how these challenges
                 have been addressed in IGLOO, the authors
                 object-oriented image and graphics research library,
                 which is written in C++. The article describes the
                 design principles underlying IGLOO and explains some
                 important trade-offs in tuning IGLOO for its
                 application domain and user community.",
  acknowledgement = ack-nhfb,
  affiliation =  "North Carolina Univ., Chapel Hill, NC, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "North Carolina Univ., Chapel Hill, NC, USA",
  keywords =     "C language; C++; computer graphics; IGLOO; image
                 processing; object-; Object-oriented design;
                 object-oriented design; oriented programming; software
                 reusability; subroutines",
  thesaurus =    "C language; Computer graphics; Image processing;
                 Object-oriented programming; Software reusability;
                 Subroutines",
  treatment =    "P Practical",
}

@Article{Schmidt:1993:EOS,
  author =       "D. C. Schmidt",
  title =        "Encapsulating operating system {IPC}s. An
                 object-oriented interface for event-driven {UNIX I/O}
                 multiplexing",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "2",
  pages =        "43--50",
  month =        feb,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "For previous part see ibid. vol.4, no.8, p.50-4, 1992.
                 The article describes a technique for encapsulating
                 existing operating system (OS) interprocess
                 communication (IPC) services within object-oriented
                 (O-O) C++ wrappers. It presents an O-O wrapper for the
                 I/O multiplexing facilities provided by the BSD
                 select() and System V UNIX poll() system calls.
                 Multiplexing is particularly useful for event-driven
                 network servers that perform I/O on many connections
                 simultaneously. The article describes a distributed
                 logging facility that motivates the need for efficient
                 I/O multiplexing, examines several alternative solution
                 approaches, evaluates the advantages and disadvantages
                 of these approaches, and compares them with the
                 Reactor. Reactor is an extensible O-O class library
                 written in C++ to provide a higher-level programming
                 abstraction that simplifies the design and
                 implementation of event-driven network applications.",
  acknowledgement = ack-nhfb,
  affiliation =  "California Univ., Irvine, CA, USA",
  classcodes =   "C6150N (Distributed systems); C6110J (Object-oriented
                 programming); C6155 (Computer communications
                 software)",
  classification = "C6110J (Object-oriented programming); C6150N
                 (Distributed systems); C6155 (Computer communications
                 software)",
  corpsource =   "California Univ., Irvine, CA, USA",
  keywords =     "BSD select(); computer communications software; data
                 encapsulation; Distributed logging facility;
                 distributed logging facility; event-driven network;
                 Event-driven network servers; event-driven UNIX I/O;
                 Event-driven UNIX I/O multiplexing; Higher-level
                 programming abstraction; higher-level programming
                 abstraction; input-; Interprocess communication;
                 interprocess communication; multiplexing; network
                 operating systems; O-O class library; Object-oriented
                 interface; object-oriented interface; object-oriented
                 programming; output programs; servers; System calls;
                 system calls; System V UNIX poll(); Unix",
  thesaurus =    "Computer communications software; Data encapsulation;
                 Input-output programs; Multiplexing; Network operating
                 systems; Object-oriented programming; Unix",
  treatment =    "P Practical",
}

@Article{Becker:1993:IPR,
  author =       "P. Becker",
  title =        "Iterators, portability, and reuse",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "2",
  pages =        "51--54",
  month =        feb,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "One very common programming task is to perform some
                 operation on each element in a set of objects. The set
                 of objects may be a group of files, and the operation
                 may be displaying the name of each of the files. This
                 task shares a common structure with other such tasks,
                 namely iteration over a set of elements. The author
                 explores that common structure, illustrate how it can
                 be encapsulated in several different forms of
                 iterators, and how those iterators help improve
                 portability and reusability of code. The author begins
                 with a simple iterator that runs into serious problems
                 when he tries to reuse it. By separating the underlying
                 concept of iteration from the particular application,
                 he creates an explicit iterator that is much more
                 reusable. By encapsulating the bookkeeping involved in
                 performing the iteration, he comes up with a callback
                 iterator. And by replacing the function pointer in the
                 callback iterator with a virtual function, he creates
                 an inherited iterator that is much safer to use than
                 the callback iterator.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "Bookkeeping; bookkeeping; C listings; Callback
                 iterator; callback iterator; Encapsulating;
                 encapsulating; Function pointer; function pointer;
                 Inherited iterator; inherited iterator; object-oriented
                 programming; Portability; portability; Reusability;
                 reusability; software; software reusability; Virtual
                 function; virtual function",
  thesaurus =    "C listings; Object-oriented programming; Software
                 portability; Software reusability",
  treatment =    "P Practical",
}

@Article{Atwood:1993:GPC,
  author =       "W. Atwood and A. Breakstone and D. Britton and T.
                 Burnett and D. Myers and G. Word",
  title =        "The {GISMO} project ({C++})",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "3",
  pages =        "38--43",
  month =        mar # "-" # apr,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The GISMO (Graphical Interface for Simulation and
                 Monte Carlo with Objects) project began as a prototype
                 to test the applicability of object-oriented techniques
                 to detector simulation and event reconstruction. It was
                 written using the Objective-C language with a graphical
                 user interface (GUI) designed using the NeXT Interface
                 Builder. GISMO will serve both as a tool to design new
                 generations of high energy physics detectors and as a
                 tool with which present-day detectors may be more
                 easily understood.",
  acknowledgement = ack-nhfb,
  affiliation =  "SLAC, Stanford Univ., CA, USA",
  classcodes =   "C7320 (Physics and Chemistry); C6180G (Graphical user
                 interfaces); C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming); C6180G
                 (Graphical user interfaces); C7320 (Physics and
                 Chemistry)",
  corpsource =   "SLAC, Stanford Univ., CA, USA",
  keywords =     "C language; C++; CAD; Detector simulation; detector
                 simulation; Event reconstruction; event reconstruction;
                 GISMO; Graphical user interface; graphical user
                 interface; graphical user interfaces; High energy
                 physics detectors; high energy physics detectors;
                 Interface Builder; language; Monte Carlo; NeXT;
                 object-oriented; Object-oriented techniques;
                 object-oriented techniques; Objective-C; Objective-C
                 language; physics computing; programming; simulation",
  thesaurus =    "C language; CAD; Graphical user interfaces;
                 Object-oriented programming; Physics computing;
                 Simulation",
  treatment =    "A Application; P Practical",
}

@Article{Sakkinen:1993:HSV,
  author =       "M. Sakkinen",
  title =        "How should virtual bases be initialized (and
                 finalized)?",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "3",
  pages =        "44--50",
  month =        mar # "-" # apr,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author argues that fork-join inheritance should
                 not be able to break the integrity of the base class
                 subobject: two paths should either share the same
                 subobject or have completely disjoint subobjects.
                 Multiple inheritance (MI) in C++ appeared to work like
                 this, in contrast to many other object-oriented
                 languages. He discusses some more subtle problems
                 caused by the C++ approach including problems with
                 virtual bases and requirements for initialization.",
  acknowledgement = ack-nhfb,
  affiliation =  "Jyvaskyla Univ., Finland",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Jyvaskyla Univ., Finland",
  keywords =     "C language; C++; fork-join; Fork-join inheritance;
                 inheritance; Initialization; initialization; Object
                 oriented programming; object oriented programming;
                 object-; Object-oriented languages; object-oriented
                 languages; oriented programming; Virtual bases; virtual
                 bases",
  thesaurus =    "C language; Inheritance; Object-oriented languages;
                 Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Dewhurst:1993:SM,
  author =       "S. C. Dewhurst",
  title =        "Subobject members",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "3",
  pages =        "51--53",
  month =        mar # "-" # apr,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "How does a base class differ from a member? This
                 article examines some techniques that allows one to
                 employ members as the functional equivalent of base
                 classes, to simplify an implementation, change a
                 synthetic relationship into a natural one, or to allow
                 source code to be tailored without altering abstract
                 type relationships or modifying the C++ source code.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "Abstract type relationships; abstract type
                 relationships; Base class; base class; C language; C++;
                 Members; members; object-oriented; object-oriented
                 languages; programming",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Webster:1993:CE,
  author =       "J. Webster and F. Douglas",
  title =        "{C++} is everywhere",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "4",
  pages =        "36--39",
  month =        may,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The authors evaluate the state of C++ applications.
                 How far has the language come since the definitions of
                 object-oriented terms and concepts were introduced into
                 the professional journals . . . since C++ was
                 introduced as a leading-edge research tool for
                 scientific applications? Current applications range
                 from complex network control to the simplest screen
                 presentations, and include everything from satellites,
                 rockets, submarines, robots, stock market options and
                 accounts payable line items. The language has come a
                 long way in the past five years, and they have asked
                 users at all ends of the spectrum-developers,
                 programmers end users-for their experiences in using
                 C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "accounts payable; Accounts payable line items; C
                 language; C++ applications; complex network; Complex
                 network control; control; line items; object-oriented
                 languages; Object-oriented terms; object-oriented
                 terms; Robots; robots; Rockets; rockets; Satellites;
                 satellites; Screen presentations; screen presentations;
                 Stock market options; stock market options; Submarines;
                 submarines",
  thesaurus =    "C language; Object-oriented languages",
  treatment =    "G General Review",
}

@Article{Reid:1993:CFP,
  author =       "R. J. Reid",
  title =        "{C++} as a first programming language",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "4",
  pages =        "41--44",
  month =        may,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Computer Science Department at Michigan State
                 University has started using C++ as the primary
                 language for programming instruction in its courses.
                 The author discusses why C++ was chosen. He explains
                 the course content, assesses results to date and
                 explores future directions.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., Michigan State Univ., East
                 Lansing, MI, USA",
  classcodes =   "C0220 (Education and training); C6140D (High level
                 languages)C6110J (Object-oriented programming)",
  classification = "C0220 (Education and training); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  corpsource =   "Dept. of Comput. Sci., Michigan State Univ., East
                 Lansing, MI, USA",
  keywords =     "C language; C++; computer science education; Course
                 content; course content; First programming language;
                 first programming language; languages;
                 object-oriented",
  thesaurus =    "C language; Computer science education;
                 Object-oriented languages",
  treatment =    "A Application; G General Review",
}

@Article{Teale:1993:TTL,
  author =       "S. Teale",
  title =        "Transplanting a tree-recursive {LISP} algorithm to
                 {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "4",
  pages =        "45--48",
  month =        may,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author takes a small program, illustrating a
                 typical tree-recursive process, written in the Scheme
                 dialect of LISP and writes a version of it in C++. A
                 tree-recursive process typically uses a function that
                 calls itself more than once, thus generating an
                 exponentially increasing number of nested
                 invocations.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming)",
  keywords =     "C listings; C++; object-oriented; object-oriented
                 languages; programming; recursive functions; Scheme;
                 software portability; Tree-recursive LISP algorithm;
                 tree-recursive LISP algorithm",
  thesaurus =    "C listings; Object-oriented languages; Object-oriented
                 programming; Recursive functions; Software
                 portability",
  treatment =    "P Practical",
}

@Article{Stroustrup:1993:LDU,
  author =       "B. Stroustrup",
  title =        "Library design using {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "5",
  pages =        "14--22",
  month =        jun,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The designer of a C++ library has several choices for
                 the basic structure of a library and can even provide
                 more than one interface style for a single library. C++
                 evolved to enable this diversity of library
                 architectures and some of the newer C++ features are
                 designed to ease the coexistence of libraries. The
                 author focuses on generalities and language support for
                 library building.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Structures Res., AT and T Bell Labs.,
                 Murray Hill, NJ, USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Dept. of Comput. Structures Res., AT\&T Bell Labs.,
                 Murray Hill, NJ, USA",
  keywords =     "C language; C listings; C++ library; Library
                 architectures; library architectures; object-;
                 object-oriented languages; oriented programming;
                 software reusability",
  thesaurus =    "C language; C listings; Object-oriented languages;
                 Object-oriented programming; Software reusability",
  treatment =    "P Practical",
}

@Article{Lea:1993:GCL,
  author =       "D. Lea",
  title =        "The {GNU C++} library",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "5",
  pages =        "24--27",
  month =        jun,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The GNU C++ library (libg++) was one of the first
                 widely available general-purpose C++ class libraries.
                 Libg++ is mainly an `abstract data structure library'.
                 Most libg++ classes are somewhat different in design
                 philosophy, design, and implementation than the classes
                 ordinarily constructed for specific application. This
                 article focuses mainly on these differences without
                 otherwise going into much detail about particular
                 components.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., State Univ. of New York, NY,
                 USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Dept. of Comput. Sci., State Univ. of New York, NY,
                 USA",
  keywords =     "Abstract data structure library; abstract data
                 structure library; abstract data types; C language;
                 General-purpose C++ class libraries; general-purpose
                 C++ class libraries; GNU C++ library; Libg++;
                 object-oriented languages; object-oriented programming;
                 software reusability",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Object-oriented programming; Software
                 reusability",
  treatment =    "P Practical",
}

@Article{Keffer:1993:DAT,
  author =       "T. Keffer",
  title =        "The design and architecture of {Tools.h}++",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "5",
  pages =        "28--33",
  month =        jun,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Rogue Wave Software's Tools.h++ has its roots in the
                 Data Analysis and Interactive Modeling Software (DAIMS)
                 project at the University of Washington. The objective
                 of the project was to develop reusable mathematical
                 modeling tools for use in fluid dynamics. The library
                 includes a set of abstract data types (ADTs), and
                 corresponding specializing classes, that provides a
                 framework for persistence, localization, and other
                 issues, although this is not the central focus of the
                 library. The author discusses the various concrete
                 classes offered by Tools.h++, then its various
                 abstraction facilities. This is followed by a look at
                 various implementation issues including implementation
                 conventions, error handling, and dynamic link
                 libraries.",
  acknowledgement = ack-nhfb,
  affiliation =  "Rogue Wave Software, Corvallis, OR, USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Rogue Wave Software, Corvallis, OR, USA",
  keywords =     "Abstract data types; abstract data types; Abstraction;
                 abstraction; and Interactive Modeling Software; C
                 language; C++ library; Data Analysis; Data Analysis and
                 Interactive Modeling Software; Dynamic link libraries;
                 dynamic link libraries; Error handling; error handling;
                 Fluid dynamics; fluid dynamics; modeling tools;
                 object-oriented languages; object-oriented programming;
                 reusable mathematical; Reusable mathematical modeling
                 tools; Rogue Wave Software; software reusability;
                 Tools.h++",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Object-oriented programming; Software
                 reusability",
  treatment =    "P Practical",
}

@Article{Carroll:1993:DUS,
  author =       "M. Carroll",
  title =        "Design of the {USL Standard Components}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "5",
  pages =        "34--39, 53",
  month =        jun,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "USL C++ Standard Components (SC) is a general-purpose
                 library. The principal design goals of SC are wide
                 utility and efficiency. SC contains a collection of C++
                 classes that are both useful and efficient in a broad
                 range of C++ programs. SC also contains tools intended
                 to make programming in C++ easier. For example. it
                 contains a tool that can produce an ASCII, T/sub E/X,
                 or Postcript representation of the class inheritance
                 hierarchy contained in a given collection of C++ source
                 files. The author restricts his attention to the
                 classes.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6110B (Software engineering
                 techniques)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  keywords =     "ASCII; C language; C++ programs; Class inheritance
                 hierarchy; class inheritance hierarchy;
                 object-oriented; object-oriented languages; Postcript;
                 programming; software reusability; TEX; USL C++
                 Standard Components",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Software reusability",
  treatment =    "P Practical",
}

@Article{Booch:1993:SBC,
  author =       "G. Booch and M. Vilot",
  title =        "Simplifying the {Booch} Components",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "5",
  pages =        "41--52",
  month =        jun,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "What factors contributed to making the C++ Booch
                 Components into `the incredible shrinking library?'
                 This article examines, how the concepts of OOD and the
                 features of C++ helped to organize and simplify the
                 library. First, it provides a brief overview of the
                 library showing its contents and organization. Then, it
                 explores how inheritance and parameterization helped to
                 streamline and simplify the library. The article
                 concludes with a summary of how much each design change
                 contributed to the overall size reduction.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++ Booch Components; Inheritance;
                 inheritance; object oriented; Object oriented design;
                 object oriented design; Object oriented programming;
                 object-oriented; object-oriented languages;
                 Parameterization; parameterization; programming;
                 Software library; software library; software
                 reusability",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Software reusability",
  treatment =    "P Practical",
}

@Article{Hansen:1993:EMA,
  author =       "T. L. Hansen",
  title =        "Enhancing memory allocation. An array
                 reallocation\slash renew function for {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "6",
  pages =        "20--22, 24, 26--30",
  month =        jul # "-" # aug,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In J. Object-Oriented Program., vol.4, no.6, p.54-9
                 (1991). A. Koenig analysed a renew operator that
                 relates to operator new and operator delete the same
                 way the realloc() function relates to the malloc() and
                 free() functions. He presented a template function
                 renew<T>() that implements the desired reallocation
                 without requiring any changes to the C++ language.
                 However, there are a couple of problems with the
                 particular implementation Koenig shows. This article
                 starts with a recap of Koenig's implementation,
                 discusses the problems with the implementation,
                 reexamines the requirements being renew<T>(), shows the
                 results of attempting to implement it on several
                 existing C++ platforms that support templates, and
                 discusses some changes that would be necessary to those
                 compilers in order to implement such a template
                 function.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  keywords =     "array reallocation/renew; Array reallocation/renew
                 function; C listings; C++ language; Compilers;
                 compilers; function; Memory allocation enhancement;
                 memory allocation enhancement; object-oriented
                 programming; Operator delete; operator delete; Operator
                 new; operator new; Renew operator; renew operator;
                 Renew<T>(); renew<T>(); storage allocation; Template
                 function; template function",
  thesaurus =    "C listings; Object-oriented programming; Storage
                 allocation",
  treatment =    "P Practical",
}

@Article{Vinoski:1993:DOC,
  author =       "S. Vinoski",
  title =        "Distributed object computing with {CORBA}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "6",
  pages =        "32--38",
  month =        jul # "-" # aug,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Object Management Group's Object Management
                 Architecture (OMA) attempts to define, at a high level
                 of abstraction, the various facilities necessary for
                 distributed O-O computing. The core of the OMA is the
                 Object Request Broker (ORB), a mechanism that provides
                 transparency of object location, activation, and
                 communication. In 1991 the OMG published revision 1.1
                 of the Common Object Request Broker Architecture
                 (CORBA) specification, a concrete description of the
                 interfaces and services that must be provided by
                 compliant ORBs. Since then, many OMG member companies
                 have either started shipping or have announced plans to
                 ship products based on the CORBA specification. The
                 CORBA is composed of five major components: ORB core;
                 interface definition language; dynamic invocation
                 interface; interface repository; and object adapters.
                 This article describes each of these components and
                 shows how they provide the flexibility required to
                 support a variety of distributed O-O systems,
                 emphasizing those developed in C++.",
  acknowledgement = ack-nhfb,
  affiliation =  "Hewlett Packard, Chelmsford, MA, USA",
  classcodes =   "C6110J (Object-oriented programming); C6150N
                 (Distributed systems)",
  classification = "C6110J (Object-oriented programming); C6150N
                 (Distributed systems)",
  corpsource =   "Hewlett Packard, Chelmford, MA, USA",
  keywords =     "Abstraction; abstraction; C language; C++; Common;
                 Common Object Request Broker Architecture; CORBA;
                 Distributed object oriented computing; distributed
                 object oriented computing; distributed processing;
                 Dynamic invocation interface; dynamic invocation
                 interface; Group; Interface definition language;
                 interface definition language; Interface repository;
                 interface repository; Object adapters; object adapters;
                 Object Management; Object Management Architecture;
                 Object Management Group; Object Request Broker
                 Architecture; object-oriented; ORB core; programming",
  thesaurus =    "C language; Distributed processing; Object-oriented
                 programming",
  treatment =    "G General Review",
}

@Article{Myers:1993:MMC,
  author =       "N. C. Myers",
  title =        "Memory management in {C++}. {I}. Fine-tuning your
                 programs",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "6",
  pages =        "39--41, 43",
  month =        jul # "-" # aug,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Because C++ code is naturally organized by class, a
                 common response to this failure is to overload member
                 operator new for individual classes. In addition to
                 being tedious to implement and maintain, however, this
                 piecemeal approach can actually hurt performance in
                 large systems. Furthermore, it tends to fragment memory
                 by keeping large, mostly empty blocks dedicated to each
                 class. The result can be a quick new/delete cycle that
                 accidentally causes virtual memory thrashing. At best,
                 the approach interferes with system-wide tuning
                 efforts. Thus, while detailed knowledge of the memory
                 usage patterns of individual classes can be helpful, it
                 is best applied by tuning memory usage for a whole
                 program or major subsystem. This article describes an
                 interface that can ease such tuning in C++ programs.
                 Before tuning a particular program, however, it pays to
                 improve performance for all programs by improving the
                 global memory manager.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  keywords =     "C language; C++ programs; Global memory manager;
                 global memory manager; Memory usage patterns; memory
                 usage patterns; object-oriented programming;
                 Performance; performance; Program fine tuning; program
                 fine tuning; storage management; system-wide;
                 System-wide tuning efforts; tuning efforts; Virtual
                 memory thrashing; virtual memory thrashing",
  thesaurus =    "C language; Object-oriented programming; Storage
                 management",
  treatment =    "P Practical",
}

@Article{Barton:1993:SEP,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Scientific and engineering programming in {C++}:
                 grafting onto our roots",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "7",
  pages =        "26--31",
  month =        sep,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Scientists and engineers typically do more numerical
                 processing than other programmers, and they tend to
                 structure their programs around mathematical models.
                 Rapid improvements in numerical processing speed and
                 the increasingly sophisticated mathematical models used
                 to formulate technical programming projects have led
                 science and engineering programmers to use C++ to
                 tackle the thorny non-numerical parts of their
                 programs. The authors discuss techniques for exploiting
                 existing FORTRAN-callable numerical libraries.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  classcodes =   "C7300 (Natural sciences); C7400 (Engineering); C6110J
                 (Object-oriented programming); C4100 (Numerical
                 analysis)",
  classification = "C4100 (Numerical analysis); C6110J (Object-oriented
                 programming); C7300 (Natural sciences); C7400
                 (Engineering)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "C listings; C++; computing; engineering computing;
                 Engineering programming; engineering programming;
                 FORTRAN-callable numerical libraries; Mathematical
                 models; mathematical models; natural sciences;
                 Nonnumerical programming; nonnumerical programming;
                 numerical analysis; Numerical processing; numerical
                 processing; object-oriented programming; Scientific
                 programming; scientific programming; subroutines",
  thesaurus =    "C listings; Engineering computing; Natural sciences
                 computing; Numerical analysis; Object-oriented
                 programming; Subroutines",
  treatment =    "P Practical",
}

@Article{Schmidt:1993:CWU,
  author =       "D. C. Schmidt",
  title =        "A {C++} wrapper for {UNIX I/O} multiplexing: the
                 object-oriented design and implementation of the
                 {Reactor}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "7",
  pages =        "32--43",
  month =        sep,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Describes techniques for encapsulating existing
                 operating system interprocess communication services
                 using object-oriented C++ wrappers. I/O multiplexing is
                 useful for developing event-driven network servers that
                 receive and process data arriving from multiple clients
                 simultaneously. This article focuses on the design and
                 implementation of a C++ wrapper called the Reactor. The
                 Reactor provides a portable interface to an
                 object-oriented library of extensible, reusable, and
                 type-secure C++ classes that encapsulate and enhance
                 the select() and poll() UNIX I/O multiplexing
                 facilities. To help simplify network programming, the
                 Reactor integrates the multiplexing of synchronous and
                 asynchronous I/O-based events together with timer-based
                 events. When these events occur, the Reactor
                 automatically dispatches previously registered
                 application-defined member functions to handle the
                 events. In addition to describing the Reactor, this
                 article also presents a distributed logging facility
                 that demonstrates how the Reactor simplifies the
                 development of concurrent, event-driven network
                 applications.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6150N
                 (Distributed systems)",
  keywords =     "application-defined; Application-defined member
                 functions; Asynchronous events; asynchronous events; C
                 listings; C++ wrapper; Concurrent applications
                 development; concurrent applications development;
                 Distributed logging facility; distributed logging
                 facility; distributed processing; Encapsulation;
                 encapsulation; event-driven; Event-driven network
                 servers; input-; member functions; multiplexing;
                 network servers; object-; Object-oriented design;
                 object-oriented design; operating; Operating system
                 interprocess communication services; oriented
                 programming; output programs; Portable interface;
                 portable interface; Reactor; software portability;
                 subroutines; Synchronous events; synchronous events;
                 system interprocess communication services; Unix; UNIX
                 I/O; UNIX I/O multiplexing",
  thesaurus =    "C listings; Distributed processing; Encapsulation;
                 Input-output programs; Multiplexing; Network servers;
                 Object-oriented programming; Software portability;
                 Subroutines; Unix",
  treatment =    "P Practical",
}

@Article{Stroustrup:1993:WCL,
  author =       "B. P. Stroustrup",
  title =        "Why consider language extensions? Maintaining a
                 delicate balance",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "7",
  pages =        "44--51",
  month =        sep,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Formal standardization of C++ started in December 1989
                 when the ANSI C++ committee, X3J16, was formed. The
                 initiative came from IBM, DEC, and HP and was supported
                 by AT and T. In June 1991 the effort became officially
                 international with the creation of the ISO SC22-WG21.
                 Thus, a single US national and international C++
                 standard will emerge. Every living programming language
                 faces a conflict between stability vs. the need to grow
                 to meet new challenges and reflect new insights. This
                 problem will not go away and must be handled delicately
                 and with common sense. As usual, one person's common
                 sense is another's lunacy, but no simple and absolute
                 rule can adequately express a policy on this matter.
                 The particular example of a proposed extension
                 discussed in this article, namespaces, is simple,
                 easily comprehended, and almost completely compatible.
                 It solves a serious problem, transition from older
                 styles to use of namespaces is easy, and it has been
                 implemented. The problem it addresses cannot be
                 adequately handled with existing language features or
                 through a library. It is an example of a proposed
                 extension that deserves to be accepted.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Structures Res., AT and T Bell Labs.,
                 Murray Hill, NJ, USA",
  classcodes =   "C6140D (High level languages)",
  classification = "C6140D (High level languages)",
  corpsource =   "Dept. of Comput. Structures Res., AT\&T Bell Labs.,
                 Murray Hill, NJ, USA",
  keywords =     "ANSI C++ committee; C language; Compatibility;
                 compatibility; International C++ standard;
                 international C++ standard; ISO SC22-WG21; Language
                 extensions; language extensions; Namespaces;
                 namespaces; Policy; policy; programming languages;
                 Stability; stability; standardisation; X3J16",
  thesaurus =    "C language; Programming languages; Standardisation",
  treatment =    "G General Review; P Practical",
}

@Article{Stal:1993:GDA,
  author =       "M. Stal and U. Steinmuller",
  title =        "Generic dynamic arrays: integrating dynamic arrays
                 into {C++} templates",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "8",
  pages =        "30--35, 38",
  month =        oct,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Dynamic arrays should be helpful in many situations
                 where scaffolding techniques once had to be applied.
                 They also provide some advantages in programmers who
                 are developing C++ libraries. The article focuses on
                 how to integrate dynamic arrays into C++ using
                 templates. An array is always an ordered collection of
                 elements. There is a distinction between homogeneous
                 arrays, where all array elements belong to the same
                 datatype, and heterogeneous arrays, where the elements
                 may have different types. The authors confine
                 themselves to homogeneous arrays, which turns out to be
                 no real limitation, since heterogeneous arrays can
                 always be modeled in C++ by using a common base class
                 for the elements (e.g. array of Object*). Additionally
                 they do not cover associative arrays or sparse arrays.
                 The arrays discussed use integral index values starting
                 with 0 to some limit without having any holes.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "abstract data types; C language; C++; C++ libraries;
                 C++ templates; Generic dynamic arrays; generic dynamic
                 arrays; Homogeneous arrays; homogeneous arrays;
                 Integral index values; integral index values;
                 libraries; Object*; object-oriented languages;
                 object-oriented programming; Scaffolding; scaffolding",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Reed:1993:EPI,
  author =       "D. R. Reed",
  title =        "Exceptions: pragmatic issues with a new language
                 feature",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "8",
  pages =        "39--44",
  month =        oct,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Deciding whether to use a new C++ feature is never
                 easy. Like all engineering decisions, there are
                 trade-offs to be made, and only you can decide which
                 ones you can afford. From his research, the author
                 found exception handling to be quite usable and looks
                 forward to using it in future projects. Currently,
                 however, the use of such a feature must be viewed as an
                 engineering trade-off. If cross-platform portability of
                 your source code is an important consideration, you may
                 want to wait a bit to use C++ exception handling. As
                 far as performance goes, it is not an issue for most
                 types of software development.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6130 (Data handling techniques)",
  classification = "C6110J (Object-oriented programming); C6130 (Data
                 handling techniques); C6140D (High level languages)",
  keywords =     "C language; C++ feature; Cross-platform portability;
                 cross-platform portability; Exception handling;
                 exception handling; object-oriented languages;
                 object-oriented programming; Software development;
                 software development; Source code; source code",
  thesaurus =    "C language; Exception handling; Object-oriented
                 languages; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Strickland:1993:OOD,
  author =       "H. Strickland",
  title =        "{ODMG}-93: the object database standard for {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "5",
  number =       "8",
  pages =        "45--48",
  month =        oct,
  year =         "1993",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The ODMG standard describes a C++ binding to an object
                 database that not only defines some C++ interface
                 classes but outlines an approach for defining database
                 classes and manipulating persistent objects. The
                 article introduces the part of the ODMG standard that
                 defines a C++ binding to an object database. This C++
                 binding not only defines some C++ interface classes,
                 but it also describes an approach for using C++ to
                 define database classes and manipulate persistent
                 objects. The author creates an abbreviation ODMG/C++ to
                 refer to this base-line subset, and concentrates on
                 only that part of the standard. The interface in this
                 subset is largely based on the common subset of
                 existing products, so it is a `codify existing
                 practice' standard.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6160J (Object-oriented databases); C6140D (High level
                 languages)",
  classification = "C6140D (High level languages); C6160J
                 (Object-oriented databases)",
  keywords =     "binding; C language; C++; C++ binding; C++ interface
                 classes; Database classes; database classes; languages;
                 Object database standard; object database standard;
                 object-oriented; object-oriented databases; ODMG-93;
                 ODMG/C++; Persistent objects; persistent objects;
                 standards",
  thesaurus =    "C language; Object-oriented databases; Object-oriented
                 languages; Standards",
  treatment =    "G General Review; P Practical",
}

@Article{Tichy:1994:GGA,
  author =       "W. F. Tichy and J. Heilig and F. {Newbery Paulisch}",
  title =        "A generative and generic approach to persistence",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "1",
  pages =        "22--33",
  month =        jan,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A persistence facility saves a program's volatile data
                 objects on permanent store for later use. In this
                 article, we propose a method that takes the drudgery
                 out of the load-process-save model. We demonstrate that
                 the persistence facility can be produced automatically
                 by a program generator. The generated routines are
                 split into type-initialization routines that are used
                 to record the information about the types used in the
                 application and generic load and save routines which
                 rely on this type information. This allows for a
                 flexible and efficient implementation of persistence as
                 well as a convenient user interface. To demonstrate the
                 feasibility of this approach, the persistence facility
                 described has been incorporated into PGen, a
                 persistence generator tool for C++. PGen has been
                 tested on several real-world applications to
                 demonstrate that the generated routines are comparable
                 in efficiency to manually written ones (in both time
                 and space).",
  acknowledgement = ack-nhfb,
  affiliation =  "Karlsruhe Univ., Germany",
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support)",
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support)",
  corpsource =   "Karlsruhe Univ., Germany",
  keywords =     "automatic programming; C language; C++; Generative
                 approach; generative approach; generic routines;
                 Generic routines; interface; languages;
                 Load-process-save model; load-process-save model;
                 object-oriented; object-oriented programming; objects;
                 Persistence facility; persistence facility; Persistence
                 generator tool; persistence generator tool; PGen;
                 Program generator; program generator;
                 Type-initialization routines; type-initialization
                 routines; user; User interface; volatile data; Volatile
                 data objects",
  thesaurus =    "Automatic programming; C language; Object-oriented
                 languages; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Churchill:1994:ERS,
  author =       "S. Churchill",
  title =        "Exception recovery with smart pointers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "1",
  pages =        "34--35, 38--42",
  month =        jan,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The C++ exception handling feature is designed to
                 eliminate the time-consuming process of passing return
                 codes up the call stack when lower-level errors occur.
                 This article describes smart pointer mechanisms that
                 can be used to provide a number of valuable services.
                 Among these is the ability to recover dynamically
                 allocated memory after an exception occurs. The author
                 starts by taking a look at a common strategy for
                 reference counting dynamically allocated objects and
                 explains how this `ref counting' can be automated using
                 smart pointers. Then he looks at how the use of smart
                 pointers provides for the recovery of dynamically
                 allocated memory when an exception occurs.",
  acknowledgement = ack-nhfb,
  affiliation =  "Fijitsu, Tokyo, Japan",
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  corpsource =   "Fijitsu, Tokyo, Japan",
  keywords =     "C language; C++ exception handling feature; Call
                 stack; call stack; coding errors; collection; data
                 structures; dynamically allocated; Dynamically
                 allocated memory; Exception recovery; exception
                 recovery; garbage; Garbage collection; Lower-level
                 errors; lower-level errors; memory; Object oriented
                 programming; object oriented programming;
                 object-oriented; programming; recovery; Reference
                 counting; reference counting; Return codes; return
                 codes; Smart pointers; smart pointers; storage
                 allocation; storage management; system",
  thesaurus =    "C language; Coding errors; Data structures;
                 Object-oriented programming; Storage allocation;
                 Storage management; System recovery",
  treatment =    "P Practical",
}

@Article{Arjomandi:1994:CSC,
  author =       "E. Arjomandi and W. O'Farrell and I. Kalas",
  title =        "Concurrency support for {C++}: an overview",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "1",
  pages =        "44--50",
  month =        jan,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "How do you handle concurrency? Whether through
                 language support or the use of libraries, the paradigms
                 of OOP and concurrent programming must work together.
                 In this article, we review and analyze some of the C++
                 based concurrent systems. Issues characterizing
                 concurrent object-oriented systems and techniques used
                 in adding concurrency to C++ are presented. We compare
                 concurrent extensions to C++, and concurrent libraries
                 for C++ where concurrency is kept outside of the
                 language.",
  acknowledgement = ack-nhfb,
  affiliation =  "York Univ., North York, Ont., Canada",
  classcodes =   "C6150N (Distributed systems); C6140D (High level
                 languages); C6110J (Object-oriented programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150N (Distributed systems)",
  corpsource =   "York Univ., North York, Ont., Canada",
  keywords =     "C language; C++ based concurrent systems; concurrency
                 control; concurrent; Concurrent extensions; concurrent
                 extensions; Concurrent libraries; Concurrent
                 object-oriented systems; Language support; language
                 support; libraries; object-oriented languages;
                 object-oriented systems; subroutines",
  thesaurus =    "C language; Concurrency control; Object-oriented
                 languages; Subroutines",
  treatment =    "G General Review",
}

@Article{Martin:1994:PEO,
  author =       "R. Martin",
  title =        "A practical example of object-oriented analysis and
                 design",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "2",
  pages =        "18--23",
  month =        feb,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Provides a case study which explores the topic of
                 object-oriented analysis and design. Although the
                 subjects of OOA and OOD are steeped in theory and
                 current controversy, the author bypasses this and
                 presents them from a pragmatic, how-to point of view.
                 There seems to be a great deal of discussion about the
                 merits of various object oriented languages. Some of
                 the participants in these discussions favor C++ as an
                 OOPL based on its nearness to C and its pragmatic
                 outlook. Others berate C++ as an ugly and incomplete
                 language because of its nearness to C and its pragmatic
                 outlook. The author makes a different point altogether:
                 the quality of an object-oriented application is
                 determined far more by the quality of its analysis and
                 design than by the features of the implementation
                 language. In his opinion, C++ offers features in
                 sufficient quantity to implement any object-oriented
                 design.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C; C language; C++; Incomplete language; incomplete
                 language; methods; object; Object oriented languages;
                 object-; object-oriented; Object-oriented analysis;
                 object-oriented analysis; Object-oriented application
                 quality; Object-oriented design; object-oriented
                 design; object-oriented languages; object-oriented
                 programming; oriented application quality; oriented
                 languages",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 methods; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Silva-Lepe:1994:RDC,
  author =       "I. Silva-Lepe and W. Hursch and G. Sullivan",
  title =        "A report on {Demeter C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "2",
  pages =        "24--30",
  month =        feb,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Reports on Demeter/C++, an object-oriented software
                 development method featuring graphical description of
                 class structures and a high level language for the
                 definition of object behaviour. C++ programs developed
                 with Demeter become less dependent on the details of a
                 specific class structure and thus more adaptive to
                 change. The Demeter method is supported by a suite of
                 tools including a graphical user interface, a
                 consistency checker, C++ code generators, and a
                 run-time library of generic software. To alleviate the
                 problem of writing large amounts of mundane code,
                 Demeter/C++ provides tools for automatically generating
                 class declarations and member function definitions.
                 Automatic code generation is based on Demeter's
                 graphical notation. The author shows how to develop a
                 sample application using Demeter/C++ and how to adapt
                 the application to new requirements.",
  acknowledgement = ack-nhfb,
  affiliation =  "Coll. of Comput. Sci., Northeastern Univ., Boston, MA,
                 USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6180G (Graphical user interfaces);
                 C6115 (Programming support)",
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages);
                 C6180G (Graphical user interfaces)",
  corpsource =   "Coll. of Comput. Sci., Northeastern Univ., Boston, MA,
                 USA",
  keywords =     "Automatic code generation; automatic code generation;
                 automatic programming; C language; C++; checker; Class
                 declarations; class declarations; Class structures;
                 class structures; Code generators; code generators;
                 consistency; Consistency checker; Demeter C++; Demeter
                 method; Demeter/C++; development method; generic;
                 Generic software; Graphical description; graphical
                 description; Graphical notation; graphical notation;
                 graphical user; Graphical user interface; graphical
                 user interface; High level language; high level
                 language; interfaces; Member function definitions;
                 member function definitions; Object behaviour
                 definition; object behaviour definition; Object
                 oriented programming; object oriented programming;
                 object-oriented; object-oriented languages;
                 object-oriented software; Object-oriented software
                 development method; programming; Run-time library;
                 run-time library; software; software tools",
  thesaurus =    "Automatic programming; C language; Graphical user
                 interfaces; Object-oriented languages; Object-oriented
                 programming; Software tools",
  treatment =    "P Practical",
}

@Article{Havener:1994:CAS,
  author =       "C. L. Havener",
  title =        "A {C++} application story",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "2",
  pages =        "31--33",
  month =        feb,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "C++ has been used at Epsilon Data Management for the
                 development of a general data warehouse system on the
                 Thinking Machines CM5 Connection Machine. Epsilon
                 creates data-based marketing solutions which often rely
                 on using large databases for decision support. This
                 type of database is often called a data warehouse.
                 Decision support queries require a pass over the entire
                 database because they take the form of finding all
                 customers who meet some requirement. We provide an
                 application story that describes our experiences, both
                 good and bad, with using C++.",
  acknowledgement = ack-nhfb,
  affiliation =  "Epsilon Data Management Inc., Burlington, MA, USA",
  classcodes =   "C6110J (Object-oriented programming); C7170
                 (Marketing); C6140D (High level languages); C6160Z
                 (Other DBMS); C7102 (Decision support systems)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6160Z (Other DBMS); C7102 (Decision
                 support systems); C7170 (Marketing)",
  corpsource =   "Epsilon Data Management Inc., Burlington, MA, USA",
  keywords =     "C language; C++; CM5; Connection Machine; Customers;
                 customers; Data warehouse; data warehouse; Data
                 warehouse system; data warehouse system; data-based;
                 Data-based marketing solutions; decision support;
                 Decision support queries; Decision support systems;
                 decision support systems; Epsilon Data Management;
                 Large databases; large databases; marketing data;
                 marketing solutions; Object oriented programming;
                 object oriented programming; object-oriented;
                 object-oriented languages; processing; programming;
                 query processing; systems; Thinking Machines; very
                 large databases",
  thesaurus =    "C language; Decision support systems; Marketing data
                 processing; Object-oriented languages; Object-oriented
                 programming; Query processing; Very large databases",
  treatment =    "A Application; P Practical",
}

@Article{Lajoie:1994:EHSa,
  author =       "J. Lajoie",
  title =        "Exception handling: supporting the runtime mechanism",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "3",
  pages =        "36--39, 42--43",
  month =        mar # "-" # apr,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The C++ exception handling mechanism can be used to
                 communicate between two unrelated portions of a C++
                 application-one portion of the application can detect
                 an exceptional situation and communicate it to the
                 portion of the application that controls or
                 synchronizes the work underway. The author reviews some
                 of the language features provided in C++ to support
                 exception handling and the underlying mechanisms an
                 implementation must provide to support these features.
                 One understands better the behavior of the C++
                 exception handling features if one understands the work
                 happening behind the scenes-the work performed by the
                 compiler and during runtime to support C++ exception
                 handling.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors); C6150J (Operating systems); C6120
                 (File organisation); C6130 (Data handling techniques)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6130 (Data handling techniques); C6140D
                 (High level languages); C6150C (Compilers, interpreters
                 and other processors); C6150J (Operating systems)",
  keywords =     "application; C++; C++ application; C++ exception
                 handling mechanism; Compiler; compiler; data
                 structures; exception handling; Exceptional situation;
                 exceptional situation; Language features; language
                 features; languages; object-oriented; program
                 compilers; Runtime mechanism; runtime mechanism;
                 Underlying mechanisms; underlying mechanisms",
  thesaurus =    "Data structures; Exception handling; Object-oriented
                 languages; Program compilers",
  treatment =    "P Practical",
}

@Article{vanLoon:1994:IXW,
  author =       "R. {van Loon}",
  title =        "Introducing the {X Window System}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "3",
  pages =        "45--47",
  month =        mar # "-" # apr,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A discussion is given on the X Window System, version
                 II and programming X in C++. The author looks at the
                 history of the X Window System or X and XII for short,
                 as well as its various components. No knowledge about X
                 or any other window system is assumed. The area of
                 graphics and window systems has always been the
                 playground of object-oriented programmers. A large
                 number of authors have used some sort of geometric
                 object-hierarchy in order to demonstrate
                 object-oriented concepts. Some of the topics presented,
                 such as the Xt/Intrinsics and Mota are only covered
                 briefly.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6180 (User interfaces); C6110J (Object-oriented
                 programming)C6140D (High level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6180 (User interfaces)",
  keywords =     "C++; concepts; geometric object-hierarchy; Geometric
                 object-hierarchy; Graphics; graphics; Mota;
                 object-oriented; Object-oriented concepts;
                 object-oriented languages; Object-oriented programmers;
                 object-oriented programming; programmers; software
                 packages; user interfaces; X Window System; XII;
                 Xt/Intrinsics",
  thesaurus =    "Object-oriented languages; Object-oriented
                 programming; Software packages; User interfaces",
  treatment =    "P Practical; R Product Review",
}

@Article{Schmidt:1994:DAN,
  author =       "D. Schmidt",
  title =        "A domain analysis of network daemon design
                 dimensions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "3",
  pages =        "50--59",
  month =        mar # "-" # apr,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Server daemons commonly provide clients with
                 communication-related services that resolve queries,
                 access file systems, manage routing tables, perform
                 local system services and integrate multiple remote
                 services. This article is part of a continuing series
                 that describes object oriented techniques that may be
                 used to simplify the development of reliable, robust
                 and extensible distributed applications. It presents an
                 object oriented domain analysis of key design decisions
                 for network server daemons.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems); C6110J (Object-oriented
                 programming); C6150J (Operating systems); C5630
                 (Networking equipment)",
  classification = "C5630 (Networking equipment); C6110J
                 (Object-oriented programming); C6150J (Operating
                 systems); C6150N (Distributed systems)",
  keywords =     "Clients; clients; Communication-related services;
                 communication-related services; distributed
                 applications; distributed processing; extensible;
                 Extensible distributed applications; File systems; file
                 systems; Local system services; local system services;
                 Multiple remote services; multiple remote services;
                 network; Network daemon design dimensions; network
                 daemon design dimensions; network operating systems;
                 Network server daemons; network server daemons; Object
                 oriented domain analysis; object oriented domain
                 analysis; Object oriented techniques; object oriented
                 techniques; object-oriented programming; Query
                 resolution; query resolution; Reliable applications;
                 reliable applications; Robust applications; robust
                 applications; Routing tables; routing tables; servers;
                 software reliability",
  thesaurus =    "Distributed processing; Network operating systems;
                 Network servers; Object-oriented programming; Software
                 reliability",
  treatment =    "P Practical",
}

@Article{Horstmann:1994:EIL,
  author =       "C. S. Horstmann",
  title =        "Extending the iostream library",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "4",
  pages =        "22--29",
  month =        may,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The first release of C++ gave two libraries, complex.h
                 and stream.h, but many C programmers still use stdio.h
                 for input and output. Streams, however, are superior to
                 stdio because they are typesafe, and their
                 extensibility goes far beyond just adding new types to
                 the formatting layer. I show that the extensibility
                 goes far beyond the addition of new types to the
                 formatting layer. I added a manipulator to convert
                 printf formatting commands to their stream equivalents,
                 and I added a new stream class that displays output in
                 a debug window under Microsoft Windows, fully
                 supporting all features of the ostream class (including
                 the new format manipulator). Both additions require
                 very little code, but the programmer must know where to
                 hook into the streams framework. This is, of course,
                 characteristic of programming with frameworks.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6150G (Diagnostic,
                 testing, debugging and evaluating systems); C6115
                 (Programming support); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages);
                 C6150G (Diagnostic, testing, debugging and evaluating
                 systems)",
  keywords =     "Buffering; buffering; C language; C++; Complex.h;
                 complex.h; Debug window; debug window; Frameworks;
                 frameworks; Input; input; Iostream library; iostream
                 library; Manipulator; manipulator; Microsoft Windows;
                 object-oriented languages; Ostream class; ostream
                 class; Output; output; Printf formatting command
                 conversion; printf formatting command conversion;
                 program debugging; Stdio.h; stdio.h; Stream.h;
                 stream.h; subroutines",
  thesaurus =    "C language; Object-oriented languages; Program
                 debugging; Subroutines",
  treatment =    "P Practical",
}

@Article{Moudgill:1994:RM,
  author =       "M. Moudgill",
  title =        "Reverse-engineering manipulators",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "4",
  pages =        "30--33",
  month =        may,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Normally, our interaction (as C++ programmers) with
                 the iostream library is confined to using the built-in
                 extraction (>>operator) and insertion (<<operator)
                 operators to read and write values, and to overloading
                 these operators to read and write user defined class
                 object. Occasionally, however, it becomes necessary to
                 use the iostream to do something other than read or
                 write a variable, such as set some iostream control
                 parameter. For example, we may wish to set the minimum
                 width of the next item to be printed. We can do this in
                 two ways. The first uses an explicit function call. The
                 other way is to use a manipulator to do it. Both of
                 these methods are illustrated. Clearly, manipulators
                 result in cleaner-looking and more compact code. Some
                 techniques for writing manipulators to replace explicit
                 function calls are outlined.",
  acknowledgement = ack-nhfb,
  affiliation =  "Cornell Univ., Ithaca, NY, USA",
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques); C6140D (High level
                 languages)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  corpsource =   "Cornell Univ., Ithaca, NY, USA",
  keywords =     "C language; C++ programmers; Explicit function call;
                 explicit function call; iostream; Iostream control
                 parameter; iostream control parameter; Iostream
                 library; item to be printed; library; manipulators;
                 Minimum width; minimum width; next; Next item to be
                 printed; object-oriented languages; Reverse-engineering
                 manipulators; reverse-engineering manipulators;
                 software engineering; subroutines; writing; Writing
                 manipulators",
  thesaurus =    "C language; Manipulators; Object-oriented languages;
                 Software engineering; Subroutines",
  treatment =    "P Practical",
}

@Article{Stal:1994:ITE,
  author =       "M. Stal and U. Steinmuller",
  title =        "Implementing a text editor using dynamic arrays",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "4",
  pages =        "34--39, 46",
  month =        may,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The article demonstrates the usage of dynamic arrays
                 in a detailed manner. The best way to gain first-hand
                 experience in the advantages of a new container class
                 is to use it in the context of a real world
                 application. To check the suitability of this dynamic
                 array implementation for nontrivial applications, a
                 UNIX ed-like line editor has been developed. The
                 model-view-controller(MVC) design pattern was chosen as
                 the appropriate application framework for the project.
                 The main objective is to cover two different aspects
                 that are important when an editor is implemented: the
                 usage of dynamic arrays for implementing the text class
                 of the editor, and the MVC concept and its applications
                 to the special case of command-line driven editors.",
  acknowledgement = ack-nhfb,
  affiliation =  "Siemens AG, Munich, Germany",
  classcodes =   "C6130D (Document processing techniques); C6150J
                 (Operating systems); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6130D
                 (Document processing techniques); C6150J (Operating
                 systems)",
  corpsource =   "Siemens AG, Munich, Germany",
  keywords =     "application; C language; Command-line driven editors;
                 command-line driven editors; Container class; container
                 class; Dynamic arrays; dynamic arrays; editor;
                 Model-view-controller design pattern;
                 model-view-controller design pattern; Nontrivial
                 applications; nontrivial applications; object-oriented
                 programming; real world; Real world application; Text
                 class; text class; text editing; Text editor; text
                 editor; Unix; UNIX ed-like line; UNIX ed-like line
                 editor",
  thesaurus =    "C language; Object-oriented programming; Text editing;
                 Unix",
  treatment =    "A Application; P Practical",
}

@Article{Lajoie:1994:EHSb,
  author =       "J. Lajoie",
  title =        "Exception handling: supporting first-class objects",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "5",
  pages =        "35--39",
  month =        jun,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Behind the scenes, library implementors can build
                 exception hierarchies, organizing exceptions into
                 groups or layers, where every layer becomes more
                 specific. This article reviews some of the language
                 features provided in C++ to support exception handling
                 as well as some of the underlying mechanisms necessary
                 to support these features.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Canada Lab., Canada",
  classcodes =   "C6110J (Object-oriented programming); C6130 (Data
                 handling techniques); C6140D (High level languages)",
  classification = "C6110J (Object-oriented programming); C6130 (Data
                 handling techniques); C6140D (High level languages)",
  corpsource =   "IBM Canada Lab., Canada",
  keywords =     "C language; C++; exception; Exception handling;
                 exception handling; Exception hierarchies; First-class
                 objects; first-class objects; hierarchies; Language
                 features; language features; library implementors;
                 Library implementors; Object oriented programming;
                 object oriented programming; object-oriented languages;
                 object-oriented programming",
  thesaurus =    "C language; Exception handling; Object-oriented
                 languages; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Coplien:1994:GPL,
  author =       "J. O. Coplien",
  title =        "Generative pattern languages: an emerging direction of
                 software design",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "6",
  pages =        "18--22, 66--67",
  month =        jul # "-" # aug,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "A generative pattern for software is like a
                 dressmaker's pattern: we use it to make something. The
                 object paradigm has reshaped the design landscape in
                 recent years. Many hold object-oriented techniques as
                 major advances in analysis and design because a single
                 set of abstractions applies equally well to
                 architecture, design, and programming. Yet a serious
                 difficulty with the object paradigm is finding the
                 right objects in the first place. Finding relationships
                 between objects, and letting object relationships shape
                 the choice of objects themselves, is perhaps an even
                 greater difficulty with object techniques. If we
                 discover, understand, and capture the patterns in a
                 given domain, we can package them as tools to make
                 inexpert designers more effective. Patterns offer broad
                 new insights and techniques that enrich the context in
                 which the designer works. Ongoing work on generative
                 pattern languages is being done by members of the
                 Hillside Patterns Group, whose members bring
                 perspectives from leading companies and industry
                 consultants in the application of object-oriented
                 techniques. The paper summarizes the state of software
                 design patterns at this early stage of exploration.",
  acknowledgement = ack-nhfb,
  affiliation =  "Software Prod. Res. Dept., AT and T Bell Labs.,
                 Naperville, IL, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Software Prod. Res. Dept., AT\&T Bell Labs.,
                 Naperville, IL, USA",
  keywords =     "Abstractions; abstractions; Generative pattern
                 languages; generative pattern languages; object; Object
                 paradigm; Object relationships; object relationships;
                 object-; object-oriented languages; object-oriented
                 methods; Object-oriented techniques; object-oriented
                 techniques; oriented programming; paradigm;
                 Programming; programming; Software design; software
                 design; Software design patterns; software design
                 patterns",
  thesaurus =    "Object-oriented languages; Object-oriented methods;
                 Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Robie:1994:EHO,
  author =       "J. Robie",
  title =        "Event handling in object-oriented databases",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "6",
  pages =        "24--27",
  month =        jul # "-" # aug,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Event handling provides a convenient way to deal with
                 some of the everyday problems that arise in database
                 programming. However, it is not a traditional paradigm
                 for database programming, and it is currently available
                 only in a very few object-oriented databases. Many
                 experienced database programmers have never even
                 thought of event handling as a database paradigm. I
                 start by exploring the original event handling
                 paradigm, which was designed for user interfaces. I
                 then show how this paradigm can be used in object
                 oriented databases and explore the relationship between
                 event handling and distributed objects. Examples are
                 based on the event handling implemented in POET, an OO
                 database system.",
  acknowledgement = ack-nhfb,
  affiliation =  "POET Software, Berlin, Germany",
  classcodes =   "C6160J (Object-oriented databases); C6110 (Systems
                 analysis and programming)",
  classification = "C6110 (Systems analysis and programming); C6160J
                 (Object-oriented databases)",
  corpsource =   "POET Software, Berlin, Germany",
  keywords =     "database; Database programmers; database programmers;
                 Database programming; Distributed objects; distributed
                 objects; Event handling; event handling;
                 Object-oriented databases; object-oriented databases;
                 POET; programming; User interfaces; user interfaces",
  thesaurus =    "Object-oriented databases; Programming; User
                 interfaces",
  treatment =    "P Practical",
}

@Article{Schmidt:1994:CSC,
  author =       "D. C. Schmidt",
  title =        "A case study of {C++} design evolution",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "6",
  pages =        "28--36",
  month =        jul # "-" # aug,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In an effort to capture the dynamics of C++ class
                 design evolution, the article illustrates the process
                 by which object-oriented techniques and C++ idioms were
                 incrementally applied to solve a relatively small, yet
                 surprisingly subtle problem. This problem arose during
                 the development of a family of concurrent distributed
                 applications that execute efficiently on uniprocessor
                 and multiprocessor platforms. This article focuses on
                 the steps involved in generalizing from existing code
                 by using templates and overloading to transparently
                 parameterize synchronization mechanisms into a
                 concurrent application. Some of the infrastructure code
                 is based on components in the freely available ADAPTIVE
                 Service eXecutive (ASX) framework.",
  acknowledgement = ack-nhfb,
  affiliation =  "California Univ., Irvine, CA, USA",
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "California Univ., Irvine, CA, USA",
  keywords =     "ADAPTIVE; ADAPTIVE Service Executive; ASX framework;
                 C++ design evolution; concurrent; Concurrent
                 distributed applications; distributed applications;
                 distributed processing; Infrastructure code;
                 infrastructure code; Multiprocessor platform;
                 multiprocessor platform; object oriented; Object
                 oriented programming; object-; object-oriented
                 languages; Object-oriented techniques; object-oriented
                 techniques; oriented programming; Overloading;
                 overloading; programming; Service Executive;
                 synchronisation; Synchronization mechanisms;
                 synchronization mechanisms; Templates; templates;
                 Uniprocessor platform; uniprocessor platform",
  thesaurus =    "Distributed processing; Object-oriented languages;
                 Object-oriented programming; Synchronisation",
  treatment =    "P Practical",
}

@Article{Vinoski:1994:MCI,
  author =       "S. Vinoski",
  title =        "Mapping {CORBA IDL} into {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "7",
  pages =        "20--23, 55",
  month =        sep,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The Common Object Request Broker Architecture (CORBA)
                 specification, produced by the Object Management Group
                 (OMG), defines a flexible framework upon which
                 distributed object-oriented applications can be built.
                 A key component of CORBA is its Interface Definition
                 Language (IDL), used to describe object interfaces and
                 specify the services they provide. IDL is a declarative
                 language that provides basic data types, constructed
                 data types, and template data types. These are used in
                 operation declarations to define argument types and
                 return types. In turn, operations are used in interface
                 declarations to specify the services provided by
                 objects. Before applications can be written to use
                 objects that have been specified in IDL, the IDL must
                 be translated into a `real' programming language. Each
                 programming language requires a different language
                 mapping that specifies how the various IDL declarations
                 are translated into it. Currently, the CORBA 1.2
                 specification describes only how IDL is mapped into the
                 C language. In December 1992, the OMG issued a request
                 for proposals for a C++ language mapping. This article
                 focuses on what appears to be the most controversial
                 issue facing those of us who are working towards a
                 standard CORBA C++ mapping: how IDL object references
                 are best mapped into C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6110F (Formal methods)",
  classification = "C6110F (Formal methods); C6110J (Object-oriented
                 programming); C6140D (High level languages)",
  keywords =     "Argument types; argument types; Basic data types;
                 basic data types; C language; C++ language mapping;
                 Common Object Request Broker Architecture; Constructed
                 data types; constructed data types; CORBA 1.2; CORBA
                 1.2 specification; CORBA IDL; data structures;
                 declarations; Declarative language; declarative
                 language; Distributed object-oriented applications;
                 distributed object-oriented applications; Flexible
                 framework; flexible framework; IDL object references;
                 interface; Interface declarations; Interface Definition
                 Language; interfaces; Management Group; object; Object;
                 Object interfaces; Object Management Group; Object
                 service specification; object service specification;
                 object-oriented languages; operation; Operation
                 declarations; Return types; return types;
                 specification; specification languages; standards;
                 Template data types; template data types",
  thesaurus =    "C language; Data structures; Object-oriented
                 languages; Specification languages; Standards",
  treatment =    "G General Review; P Practical",
}

@Article{Crawford:1994:RP,
  author =       "J. Crawford",
  title =        "Runtime parameterization. 1",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "7",
  pages =        "24--29",
  month =        sep,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "It's a pity about the <generic.h> macros. They were
                 such a cunningly fashioned means of parameterizing
                 generic types that one almost half regrets their
                 obsolescence. But only half. Templates are such a
                 tidier way of achieving compile-time parameterization
                 that the appetite is whetted for a similar mechanism
                 that will delay the choice of the parameter until
                 run-time. In this article, I sketch a scenario in which
                 run-time parameterization would suit our needs better
                 than the compile-time variety.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Studies, Inst. of Technol., Aukland,
                 New Zealand",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Dept. of Comput. Studies, Inst. of Technol., Aukland,
                 New Zealand",
  keywords =     "C language; C++ programming; compile-time;
                 Compile-time parameterization; object-oriented
                 programming; Parameter selection; parameter selection;
                 parameterization; Run-time parameterization; run-time
                 parameterization; Templates; templates",
  thesaurus =    "C language; Object-oriented programming",
  treatment =    "P Practical",
}

@Article{Vilot:1994:IST,
  author =       "M. J. Vilot",
  title =        "An introduction to the {Standard Template Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "8",
  pages =        "22--29, 35",
  month =        oct,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Developed at Hewlett--Packard, the Standard Template
                 Library (STL) contains general-purpose mechanisms,
                 using C++'s templates for component parameterization. A
                 notable aspect of this library is that it focuses
                 primarily on algorithms-once thought to be the
                 exclusive province of FORTRAN subroutine libraries.
                 This article focuses on using STL, rather than on
                 presenting a comprehensive treatment of its internal
                 technical details. The first section provides an
                 overview of the library. The second section provides a
                 series of C++ code examples that illustrate various
                 aspects of using the library's `algorithm-oriented
                 generic software' approach. Finally, the last section
                 concludes with a more detailed overview of the library.
                 It can be used as a roadmap to the detailed reference
                 material.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "algorithm-oriented generic software;
                 Algorithm-oriented generic software; C language; C++
                 code; C++ templates; component parameterization;
                 Component parameterization; general-purpose;
                 General-purpose mechanisms; Hewlett--Packard;
                 mechanisms; object-oriented programming; software
                 libraries; Standard Template Library; STL",
  thesaurus =    "C language; Object-oriented programming; Software
                 libraries",
  treatment =    "P Practical",
}

@Article{Stroustrup:1994:MVF,
  author =       "B. Stroustrup",
  title =        "Making a vector fit for a standard",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "8",
  pages =        "30--34",
  month =        oct,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "An important detail of the design of a vector template
                 class is discussed: how to generalize a vector in such
                 a way that it can be used conveniently with a variety
                 of memory models. This vector from A. Stepanov and M.
                 Lee's (1994) Standard Template Library (STL) is part of
                 a large, systematic, clean, formally sound,
                 comprehensible, elegant and efficient framework. The
                 presentation progresses through a series of versions of
                 the vector class, from the most obvious to the vector
                 from the STL library, which is part of the C++
                 standard. Each example presents a problem, a solution
                 to that problem, and notes that the simplest and most
                 common uses of the vector class remain unchanged under
                 the various generalizations.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "abstract data types; C language; C++ standard;
                 Generalizations; generalizations; Memory models; memory
                 models; object-oriented languages; software libraries;
                 Standard Template Library; standards; STL; Vector
                 template class; vector template class",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Software libraries; Standards",
  treatment =    "P Practical",
}

@Article{Davis:1994:ACC,
  author =       "S. R. Davis",
  title =        "Armor cladding {C++} classes",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "6",
  number =       "8",
  pages =        "36--39, 41",
  month =        oct,
  year =         "1994",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Bugs exist in any nontrivial program. We must protect
                 ourselves against them. The small extra effort required
                 to build in test code to detect and report errors is
                 repaid many times over during debugging and testing. A
                 good place to add such checks are at the interfaces
                 between a class and the application. The principle of
                 division of labor says that a class should be
                 responsible for its own welfare. This includes making
                 the class resistant to illegal input. I examine a few
                 techniques for making classes resistant to abuse. The
                 checks presented are for debugging purposes only. The
                 goal is not to process garbage input, only to recognize
                 and flag it to the programmer as clearly as possible.
                 While the techniques mentioned in this article cannot
                 detect all errors, they can detect a large class of
                 errors quickly and efficiently, greatly reducing the
                 amount of effort spent in the debugging and testing
                 phase, and increasing the quality of the final
                 product.",
  acknowledgement = ack-nhfb,
  affiliation =  "E-Systems, Greenville, TX, USA",
  classcodes =   "C6110J (Object-oriented programming); C6150G
                 (Diagnostic, testing, debugging and evaluating
                 systems)",
  classification = "C6110J (Object-oriented programming); C6150G
                 (Diagnostic, testing, debugging and evaluating
                 systems)",
  corpsource =   "E-Systems, Greenville, TX, USA",
  keywords =     "C language; C++ classes; class-application;
                 Class-application interfaces; classes; Division of
                 labour; division of labour; Error detection; error
                 detection; Error reporting; error reporting; Garbage
                 input flagging; garbage input flagging; Illegal input;
                 illegal input; interfaces; object-oriented programming;
                 Program debugging; program debugging; Program testing;
                 program testing; resistant; Resistant classes; Software
                 quality; software quality; Test code; test code",
  thesaurus =    "C language; Object-oriented programming; Program
                 debugging; Program testing; Software quality",
  treatment =    "P Practical",
}

@Article{Speh:1995:CWW,
  author =       "M. Speh and C. Dinnell",
  title =        "{C++} and the {World Wide Web}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "1",
  pages =        "18--23",
  month =        jan,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Since it joined the WWW in early 1993, the C++ Virtual
                 library has evolved into a huge catalogue of C++
                 documents. The article deals briefly with getting on
                 the Web, and discusses information resources of
                 particular interest to the C++ users' community. At the
                 end, you should have a rough idea of what's waiting for
                 you out there on the Web. Even more importantly, you
                 will know how you can contribute to the Web yourself
                 either as a lone C++ programmer or as a software
                 company, and how you can use it as a sophisticated tool
                 for teaching and learning C++. Only a minimum of
                 technical information is necessary to get to the Web
                 and use it effectively. The World Wide Web is a wide
                 area hypermedia information retrieval initiative aiming
                 to give universal access to a large universe of
                 documents.",
  acknowledgement = ack-nhfb,
  classcodes =   "B6210L (Computer communications); C7250N (Front end
                 systems for online searching); C5620W (Other computer
                 networks); C7210 (Information services and centres);
                 C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "B6210L (Computer communications); C5620W (Other
                 computer networks); C6110J (Object-oriented
                 programming); C6140D (High level languages); C7210
                 (Information services and centres); C7250N (Front end
                 systems for online searching)",
  keywords =     "C language; C++ documents; C++ programmer; C++ user
                 community; C++ Virtual library; front-ends; Information
                 resources; information resources; Internet;
                 object-oriented languages; online; retrieval; Software
                 company; software company; Teaching; teaching;
                 Universal access; universal access; wide area
                 hypermedia information; Wide area hypermedia
                 information retrieval; World Wide Web; WWW",
  thesaurus =    "C language; Internet; Object-oriented languages;
                 Online front-ends",
  treatment =    "P Practical",
}

@Article{Flanagin:1995:DIC,
  author =       "G. Flanagin and N. Rimmer",
  title =        "Doing it ({C++} software reuse project)",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "1",
  pages =        "24--28",
  month =        jan,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "We discuss a small software project centered around
                 the construction and use of reusable software
                 components at an introductory scale. Starting with bare
                 code fragments, we assembled a small class library
                 suitable for use in other parts of our company. As a by
                 product of this pilot project, we were able to define
                 several levels of reuse, and thereby provide a valuable
                 vocabulary for discussing reusable components. These
                 results imply that reuse is indeed doable on an
                 incremental basis. We found that if reuse is a goal at
                 the beginning, it is attainable. We hope that readers
                 will be able to put these findings to good use in
                 development and project planning.",
  acknowledgement = ack-nhfb,
  affiliation =  "Thuridion, Scotts Valley, CA, USA",
  classcodes =   "C6110B (Software engineering techniques); C6140D (High
                 level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  corpsource =   "Thuridion, Scotts Valley, CA, USA",
  keywords =     "C language; C++ software reuse project; Code
                 fragments; code fragments; object-oriented languages;
                 project management; Project planning; project planning;
                 reusable; Reusable software components; Small class
                 library; small class library; Small software project;
                 small software project; software components; software
                 reusability",
  thesaurus =    "C language; Object-oriented languages; Project
                 management; Software reusability",
  treatment =    "P Practical",
}

@Article{Carroll:1995:TIC,
  author =       "M. Carroll and M. Ellis",
  title =        "Tradeoffs of interface classes",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "1",
  pages =        "29--32",
  month =        jan,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "We discuss the tradeoffs of C++ interface classes and
                 inheritance hierarchies built with interface
                 classes-interfaced hierarchies. We also weigh the
                 advantages and disadvantages of providing object
                 factories with interfaced hierarchies.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "C language; C++ interface classes; hierarchies;
                 inheritance; Inheritance hierarchies; inheritance
                 hierarchies; interfaced; Interfaced hierarchies; Object
                 factories; object factories; object-; object-oriented
                 languages; oriented programming; software libraries",
  thesaurus =    "C language; Inheritance; Object-oriented languages;
                 Object-oriented programming; Software libraries",
  treatment =    "P Practical",
}

@Article{Barton:1995:DA,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Dimensional analysis",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "1",
  pages =        "39--40, 42--43",
  month =        jan,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Dimensional analysis was adopted for hand computation
                 of physical formulas for the same reason that type
                 checking was added to computer programming languages:
                 to catch errors as early as possible. Computing with
                 dimensional analysis is simply a matter of using the
                 appropriate data types in computations and letting the
                 C++ type system do the checking. Function templates
                 returning types computed from the argument types make
                 the construction of dimensional analysis data types
                 especially easy.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Thomas J. Watson Res. Center, Yorktown Heights,
                 NY, USA",
  classcodes =   "C7310 (Mathematics computing); C6140D (High level
                 languages); C6110J (Object-oriented programming); C6120
                 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages); C7310
                 (Mathematics computing)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Yorktown Heights,
                 NY, USA",
  keywords =     "abstract data types; argument; Argument types; C
                 language; C++; C++ type system; Data types; data types;
                 Dimensional analysis; dimensional analysis; Function
                 templates; function templates; mathematics computing;
                 object-oriented languages; object-oriented programming;
                 Physical formulas; physical formulas; Type checking;
                 type checking; type system; types",
  thesaurus =    "Abstract data types; C language; Mathematics
                 computing; Object-oriented languages; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Horstmann:1995:ODT,
  author =       "C. S. Horstmann",
  title =        "{OO} design tools with {C++} code generation",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "1",
  pages =        "56--58, 60--64",
  month =        jan,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "I focus on the aspect of the various object-oriented
                 design methodologies that seem useful and
                 noncontroversial: capture and diagramming of key
                 classes, class properties and class relationships. My
                 particular concern is how these activities integrate
                 with ongoing code development.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Math. and Comput. Sci., San Jose State Univ.,
                 CA, USA",
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6120 (File organisation)",
  classification = "C6110F (Formal methods); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  corpsource =   "Dept. of Math. and Comput. Sci., San Jose State Univ.,
                 CA, USA",
  keywords =     "abstract data types; C language; C++ code generation;
                 class; Class capture; class capture; Class diagramming;
                 class diagramming; Class properties; Class
                 relationships; class relationships; Code development;
                 code development; methodologies; object-oriented
                 design; Object-oriented design methodologies;
                 object-oriented languages; object-oriented methods;
                 object-oriented programming; OO design tools;
                 properties",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Object-oriented methods; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Vilot:1995:CSL,
  author =       "M. J. Vilot",
  title =        "The {C++} standard library",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "2",
  pages =        "28--34",
  month =        feb,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In March 1995, the C++ standardization effort will
                 enter its sixth year. Although progress on the
                 definition of Standard C++ may appear to be
                 frustratingly slow, the pace of any standardization
                 effort is deliberate. In this case, it has provided
                 interested members of the C++ community with the time
                 to consider, debate, and anticipate the effects the
                 eventual Standard will have on the language and its
                 users. The article presents an overview of the contents
                 of the C++ Standard Library. The description of this
                 library is based on the current Working Paper for the
                 ANSI XJ16 (ISO WG21) committee, and is therefore
                 subject to change. However, the basic scope and nature
                 of the components in the library are well
                 established.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6115 (Programming support); C6110J (Object-oriented
                 programming); C6140D (High level languages)",
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages)",
  keywords =     "ANSI XJ16; C language; C++; C++ community; C++
                 standard library; C++ standardization effort; ISO; ISO
                 WG21; object-oriented languages; software libraries;
                 software standards; Standard; Standard C++;
                 Standardization effort; standardization effort; WG21",
  thesaurus =    "C language; Object-oriented languages; Software
                 libraries; Software standards",
  treatment =    "P Practical",
}

@Article{Remba:1995:SCG,
  author =       "D. Remba",
  title =        "A survey of the computer generated imagery landscape",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "2",
  pages =        "36--41",
  month =        feb,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The field of computer graphics truly has a limitless
                 horizon. The applications and content that rely on CGI
                 (computer generated imagery) techniques are becoming
                 ubiquitous. Multimedia and CD-ROM technology have
                 provided yet another outlet for CGI based images and
                 animations in the form of games, educational software,
                 and other yet to be discovered applications. The
                 successful CD-ROM based Myst game exploration
                 environment is an example of a new hybrid application.
                 This is a totally synthetic 3D environment with a story
                 behind it, which you explore and discover at your own
                 pace. There is no element of reflex or timing in this
                 game, but rather an ambiance and an engaging virtual
                 world.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130B (Graphics techniques); C7820 (Humanities
                 computing); C6130M (Multimedia); C6180 (User
                 interfaces); C6160S (Spatial and pictorial databases);
                 C7830D (Computer games)",
  classification = "C6130B (Graphics techniques); C6130M (Multimedia);
                 C6160S (Spatial and pictorial databases); C6180 (User
                 interfaces); C7820 (Humanities computing); C7830D
                 (Computer games)",
  keywords =     "CD-ROM technology; CD-ROMs; CGI based images; computer
                 animation; computer games; Computer generated imagery
                 landscape; computer generated imagery landscape;
                 Computer graphics; computer graphics; computing;
                 Educational software; educational software; Games;
                 games; Hybrid application; hybrid application;
                 Multimedia; multimedia; Myst game exploration
                 environment; Synthetic 3D environment; synthetic 3D
                 environment; virtual reality; Virtual world; virtual
                 world",
  thesaurus =    "CD-ROMs; Computer animation; Computer games;
                 Multimedia computing; Virtual reality",
  treatment =    "P Practical",
}

@Article{Hickey:1995:CCU,
  author =       "R. Hickey",
  title =        "Callbacks in {C++} using template functors",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "2",
  pages =        "42--50",
  month =        feb,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "One of the many promises of object oriented
                 programming is that it will allow for plug and play
                 software design with reusable components. Designers
                 will pull objects from their library `shelves' and hook
                 them together to make software. In C++, this hooking
                 together of components can be tricky, particularly if
                 they are separately designed. We are still a long way
                 from interoperable libraries and application
                 components. Callbacks provide a mechanism whereby
                 independently developed objects may be connected
                 together. They are vital for plug and play programming,
                 since the likelihood of Vendor A implementing their
                 library in terms of Vendor B classes, or your home
                 brewed classes, is nil. Callbacks are in wide use;
                 however, current implementations differ and most suffer
                 from shortcomings, not the least of which is their lack
                 of generality. The article describes what callbacks
                 are, how they are used, and the criteria for a good
                 callback mechanism. It summarizes current callback
                 methods and their weaknesses. It then describes a
                 flexible, powerful, and easy to use callback technique
                 based on template functors-objects that behave like
                 functions.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6110B (Software engineering
                 techniques)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  keywords =     "C language; C++ callbacks; Callback mechanism;
                 callback mechanism; Callback methods; callback methods;
                 Object oriented programming; object oriented
                 programming; object-oriented; object-oriented
                 languages; play programming; plug and; Plug and play
                 programming; programming; Reusable components; reusable
                 components; software portability; software reusability;
                 Template functors; template functors",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Software portability; Software
                 reusability",
  treatment =    "P Practical",
}

@Article{Kontogiorgos:1995:CTA,
  author =       "T. Kontogiorgos and M. Kim",
  title =        "A {C++} template-based application architecture",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "2",
  pages =        "51--56, 58",
  month =        feb,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Tapar is an application architecture for building
                 complex IS applications using C++. It provides an
                 architecture for the following: persistent storage of
                 C++ objects on a relational database; compile time type
                 checked interface to the persistent storage and value
                 management for application data types; memory
                 management of C++ objects; mapping between object and
                 relational models. Persistent storage of C++ objects on
                 a relational database allows applications developed in
                 Tapar to leverage the mature relational database
                 technology. There are two issues to be considered:
                 object (logical) model to physical model mapping; and
                 transaction control. The application data type value
                 management addresses the issues of value validation,
                 default value generation, and compile time protection
                 from possibly dangerous assignments. The C++ object
                 memory management functionality ensures that only one
                 instance of a persistent object is kept in memory and
                 is properly shared. Tapar does not use any facilities
                 other than those provided by the C++ language and
                 simple macro expansions. It maintains the C++ data
                 model of static name resolutions thereby avoiding any
                 sort of run time symbolic manipulations. We describe
                 the three layers of Tapar. These are the object layer,
                 the process layer and persistence.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "abstract data types; Application data type value
                 management; application data type value management;
                 Application data types; application data types; C
                 language; C++ data model; C++ object memory management
                 functionality; C++ objects; C++ template-based
                 application architecture; compile time; Compile time
                 protection; Compile time type checked interface;
                 compile time type checked interface; complex; Complex
                 IS applications; database; Default value generation;
                 default value generation; IS applications; management;
                 Memory management; memory management; object-oriented
                 languages; object-oriented programming; Persistent
                 object; persistent object; Persistent storage;
                 persistent storage; protection; relational; Relational
                 database; Run time symbolic manipulations; run time
                 symbolic manipulations; Static name resolutions; static
                 name resolutions; storage management; Tapar;
                 Transaction control; transaction control; value; Value
                 management; Value validation; value validation",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Object-oriented programming; Storage
                 management",
  treatment =    "P Practical",
}

@Article{Vinoski:1995:DEM,
  author =       "S. Vinoski and D. Schmidt",
  title =        "{DOC} by example: modelling distributed object
                 applications",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "2",
  pages =        "64--68",
  month =        feb,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "We present an extended example that compares and
                 contrasts different ways of using C++ and DOC to solve
                 a representative distributed programming application.
                 Our example centers around a financial services system,
                 with a distributed architecture. We focus on a stock
                 trading application that enables investment brokers to
                 query stock prices, as well as buy shares of stock. The
                 quote server that maintains the current stock prices is
                 physically remote from brokers, who work in various
                 geographically distributed sites. Therefore, our
                 application must be developed to work efficiently,
                 robustly, and securely across a variety of wide area
                 networks (WAN) and local area (LAN) networks. We
                 selected the stock trading application since the issues
                 involved in analyzing, designing, and implementing it
                 are remarkably similar to many other types of
                 distributed applications.",
  acknowledgement = ack-nhfb,
  classcodes =   "C7120 (Financial computing); C6110J (Object-oriented
                 programming); C6110P (Parallel programming); C6150N
                 (Distributed systems software); C6140D (High level
                 languages)",
  classification = "C6110J (Object-oriented programming); C6110P
                 (Parallel programming); C6140D (High level languages);
                 C6150N (Distributed systems software); C7120 (Financial
                 computing)",
  keywords =     "C language; C++; Distributed architecture; distributed
                 architecture; Distributed object application modelling;
                 distributed object application modelling; DOC;
                 Financial services system; financial services system;
                 Geographically distributed sites; geographically
                 distributed sites; Investment brokers; investment
                 brokers; Local area networks; local area networks;
                 networks; object-oriented; object-oriented languages;
                 parallel programming; programming; quote; Quote server;
                 Representative distributed programming application;
                 representative distributed programming application;
                 server; stock; stock markets; Stock prices; stock
                 prices; Stock trading application; trading application;
                 WAN; wide area; Wide area networks",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Parallel programming; Stock markets",
  treatment =    "P Practical",
}

@Article{Ellis:1995:TE,
  author =       "M. Ellis and M. Carroll",
  title =        "Tradeoffs of exceptions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "12, 14, 16",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The introduction of the exception handling feature
                 into the C++ language comes with tradeoffs. The most
                 significant advantage is that exception handling allows
                 C++ code to handle errors and other exceptional
                 conditions elegantly. On the other hand, the presence
                 of exceptions in C++ necessitates that special care be
                 taken to ensure that code is exception safe. Classes
                 must be designed so objects are not rendered
                 inconsistent when an exception is thrown. Libraries
                 must be designed to avoid resource leaks and other ill
                 effects of the nonlocal flow of control caused by an
                 exception having been thrown.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++ language; conditions; exception
                 handling; Exception handling feature; exception
                 handling feature; exceptional; Exceptional conditions;
                 Nonlocal flow; nonlocal flow; object-oriented
                 languages; Resource leaks; resource leaks",
  thesaurus =    "C language; Exception handling; Object-oriented
                 languages",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Meyers:1995:BOI,
  author =       "S. Meyers",
  title =        "Bounding object instantiations. {I}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "18--22",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Using C++, suppose you've only got one printer in your
                 system, so you'd like to somehow limit the number of
                 printer objects to one. Or you've only got 16 file
                 descriptors you can hand out, so you've got to make
                 sure there are never more than that many file
                 descriptor objects in existence. How can you do such
                 things? How can you limit the number of objects?.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++; descriptor object; file; File
                 descriptor object; Object instantiations bounding;
                 object instantiations bounding; object-oriented
                 languages; Printer objects; printer objects",
  thesaurus =    "C language; Object-oriented languages",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Jordan:1995:IOO,
  author =       "D. Jordan",
  title =        "Identifying {ODMG} objects",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "24, 26--27",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Object identifiers, their use as database references
                 and their implementation, are among the fundamental
                 components within the architecture of an object
                 database. In evaluating the performance of an object
                 database, for example, the efficiency of mapping from
                 object identifiers to the actual object is one of the
                 primary factors investigated. Each of the object
                 database vendors takes a different approach to
                 implementing this mapping. This article will discuss
                 entity and object identifiers, contrast their use in
                 relational and object oriented databases, and discuss
                 their specification within the ODMG standard. When
                 applications are designed and developed, the entities
                 modelled in the problem domain usually have identifiers
                 associated with them to uniquely reference them.
                 Sometimes an entity will have a natural, real world
                 name associated with it and this name often becomes the
                 identifier used in the software model. In other cases
                 there is no name in the real world so an identifier is
                 concocted using a sequence number generation facility
                 or some other similar mechanism.",
  acknowledgement = ack-nhfb,
  affiliation =  "AT and T Bell Labs., USA",
  classcodes =   "C6160J (Object-oriented databases); C6110J
                 (Object-oriented programming); C6140D (High level
                 languages)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6160J (Object-oriented databases)",
  corpsource =   "AT\&T Bell Labs., USA",
  keywords =     "C language; Database references; database references;
                 Entity identifiers; entity identifiers; languages;
                 model; Object database; object database; Object
                 identifiers; object identifiers; object-oriented;
                 object-oriented databases; ODMG objects; Sequence
                 number generation facility; sequence number generation
                 facility; software; Software model; Specification;
                 specification",
  thesaurus =    "C language; Object-oriented databases; Object-oriented
                 languages",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Box:1995:BCC,
  author =       "D. Box",
  title =        "Building {C++} components using {OLE2}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "28--34",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Object linking and embedding Version 2 (OLE2) and its
                 underlying Component Object Model are Microsoft's
                 solution to the problem of object interoperability,
                 both at the application level and at the system level.
                 OLE is essentially a family of interfaces (or data
                 types) that provide an architecture for
                 application-level services (e.g., Compound Documents,
                 Scripting, Controls, and Extensions). These interfaces
                 define the protocol that is used to access OLE
                 functionality either from system or user-provided
                 classes. All OLE interfaces are specified and
                 implemented using the Component Object Model.",
  acknowledgement = ack-nhfb,
  affiliation =  "DevelopMentor, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150N (Distributed systems
                 software)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150N (Distributed systems
                 software)",
  corpsource =   "DevelopMentor, USA",
  keywords =     "Application-level services; application-level
                 services; C language; Component object model; component
                 object model; Compound documents; compound documents;
                 Controls; controls; Data types; data types; distributed
                 processing; Extensions; extensions; interoperability;
                 languages; object; Object interoperability; Object
                 linking; object linking; object-oriented; OLE
                 functionality; OLE2; open systems; Protocol; protocol;
                 Scripting; scripting; User-provided classes;
                 user-provided classes",
  thesaurus =    "C language; Distributed processing; Object-oriented
                 languages; Open systems",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Vlissides:1995:PHG,
  author =       "J. Vlissides",
  title =        "Pattern hatching-perspectives from the ``gang of
                 four''",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "36--39",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The author discusses design patterns as the basis for
                 reusable object-oriented software design.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "design patterns; Design patterns; object-oriented
                 programming; Pattern hatching; pattern hatching;
                 reusable object-oriented; Reusable object-oriented
                 software design; software design; software
                 reusability",
  thesaurus =    "Object-oriented programming; Software reusability",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Lajoie:1995:SUT,
  author =       "J. Lajoie",
  title =        "Standards update: type conversions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "40--46",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "New categories of standard conversions have been
                 created to describe the implicit conversions performed
                 by an implementation in C++.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++; conversions; Implicit conversions;
                 implicit conversions; object-oriented languages;
                 software standards; Standard conversions; standard
                 conversions; type; Type conversions",
  thesaurus =    "C language; Object-oriented languages; Software
                 standards",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Schmidt:1995:UDP,
  author =       "D. C. Schmidt and P. Stephenson",
  title =        "Using design patterns to evolve system software from
                 {UNIX} to {Windows NT}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "47--60",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Developing system software that is reusable across OS
                 platforms is challenging. Due to constraints imposed by
                 the underlying OS platforms, it is often impractical to
                 directly reuse existing algorithms, detailed designs,
                 interfaces,or implementations. This article describes
                 our experiences using a large-scale reuse strategy for
                 system software based on design patterns. Design
                 patterns capture the static and dynamic structures of
                 solutions that occur repeatedly when producing
                 applications in a particular context. Design patterns
                 are an important technique for improving system
                 software quality since they address a fundamental
                 challenge in large-scale software development:
                 communication of architectural knowledge among
                 developers. Our experiences with a large-scale reuse
                 strategy based upon design patterns are described. This
                 strategy has been used to facilitate the development of
                 efficient OO telecommunication system software at
                 Ericsson. We present a case study that describes the
                 cross-platform evolution of portions of an OO framework
                 called the ADAPTIVE Service Executive (ASX). The ASX
                 framework is an integrated collection of components
                 that collaborate to produce a reusable infrastructure
                 for developing distributed applications.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  keywords =     "ADAPTIVE Service; ADAPTIVE Service Executive;
                 architectural; Architectural knowledge; Cross-platform
                 evolution; cross-platform evolution; Design patterns;
                 design patterns; Distributed applications; distributed
                 applications; Executive; knowledge; large-; Large-scale
                 reuse strategy; object-oriented programming;
                 reusability; Reusable infrastructure; reusable
                 infrastructure; scale reuse strategy; software;
                 software portability; System software; system software;
                 System software quality; system software quality; UNIX;
                 Windows NT",
  thesaurus =    "Object-oriented programming; Software portability;
                 Software reusability",
  treatment =    "P Practical",
}

@Article{Barton:1995:ACO,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Algebra for {C++} operators",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "70--74",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "We started out in search of a way to express
                 completeness of and consistency among operators defined
                 for C++ classes. We applied a time-honored method: we
                 stole the solution developed in an existing branch of
                 mathematics and twisted it around until it solved our
                 problem. The mathematics we used was abstract algebra;
                 the twisting involved focusing on the operations that
                 C++ allows us to redefine and ignoring any aspect of
                 abstract algebra that did not help us to get a
                 consistent set of operations for a class. As important
                 as the consistent operations, we also get well defined
                 names for categories of consistent operations: we can
                 look at ComplexFloat, see that it is derived from
                 FieldCategory and, with a little practice, know exactly
                 what arithmetic operations it will have and how they
                 are related. What's more, function code in the template
                 base classes gets reused in any class derived from
                 them. Our expression of the abstract algebra used
                 relatively new techniques in C++: function declaration
                 injection and derived-class parameterized base classes.
                 Two compilers we tried support these techniques, but
                 some older compilers may choke. We do not discuss
                 performance, but we note that a good compiler will
                 expand the simple inline functions we use in these
                 templates.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C4210 (Formal logic)",
  classification = "C4210 (Formal logic); C6110J (Object-oriented
                 programming); C6140D (High level languages)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "Abstract algebra; abstract algebra; C language; C++
                 classes; C++ operators; Compilers; compilers;
                 consistent; Consistent operations; Derived-class
                 parameterized base classes; derived-class parameterized
                 base classes; Function code; function code; Function
                 declaration injection; function declaration injection;
                 functions; inline; Inline functions; object-oriented;
                 object-oriented languages; operations; process algebra;
                 programming",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Process algebra",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Flanagan:1995:RBS,
  author =       "E. B. Flanagan",
  title =        "Risky business (software development management)",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "3",
  pages =        "75--76, 78",
  month =        mar # "-" # apr,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Every activity has risk; and the development of
                 software has a place on the list of activities that
                 involve significant risk. Perhaps that's simply a side
                 effect of it's dependence on people rather than
                 machines such as in manufacturing. Regardless of our
                 efforts to introduce order and structure to the
                 process, even to use software factory type models, each
                 software project is new; and the construction or
                 introduction of anything new involves risk The
                 recognition and evaluation of that risk is critically
                 important if it is to be managed. The activities in
                 software development are as varied as the introduction
                 of a new primary technology, such as object-oriented
                 technology, process changes to support new paradigms of
                 development, new technologies to augment your current
                 object-oriented development environments, or a new
                 project. All of these involve some risk. The risks in
                 our projects or environments can be broken down into
                 several categories such as business, management, staff
                 process, or the technology. The author focuses on the
                 risks for software development organizations as part of
                 the larger business.",
  acknowledgement = ack-nhfb,
  classcodes =   "C0310F (Software development management)",
  classification = "C0310F (Software development management)",
  keywords =     "development; development organizations;
                 Object-oriented development environments;
                 object-oriented development environments;
                 Object-oriented technology; object-oriented technology;
                 Process changes; process changes; risk management;
                 software; Software development; software development
                 management; Software development organizations;
                 Software factory type models; software factory type
                 models; Software project; software project",
  thesaurus =    "Risk management; Software development management",
  treatment =    "P Practical",
}

@Article{Box:1995:PKP,
  author =       "Don Box",
  title =        "Porting to {Klingon} --- Porting source code written
                 to process {English} language text to other languages
                 is not easily done. {Don} explains why {Unicode} is
                 important for {Windows} developers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "4",
  pages =        "15--19",
  month =        may,
  year =         "1995",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 23 10:27:26 1998",
  acknowledgement = ack-rc,
}

@Article{Berg:1995:OFI,
  author =       "B. Berg and E. Rowlance",
  title =        "An object-oriented framework for {I/O}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "4",
  pages =        "28--35",
  month =        may,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "I/O is a natural area for the application of OOD and
                 programming. The domain contains a wealth of physical
                 items that are easy to pick up and grab as objects. As
                 the IBM Rochester laboratory approached the task of
                 moving the AS/400 operating system from the proprietary
                 based processor architecture used since its
                 introduction to a new RISC based architecture, we
                 realized there would be a significant number of changes
                 required in the lower layers. We had also become aware
                 of the limitations of the old software design related
                 to I/O support. In 1990, the IBM lab in Rochester had
                 decided on C++ as the strategic language for internal
                 development and had began building on our experience
                 with object based programming (abstract data types). As
                 we looked at the requirements and amount of code change
                 required to meet them, we decided that we needed to
                 rewrite significant portions of the code that would
                 support I/O on the new machine. OOD and C++ were the
                 logical choice for development. The article describes
                 the framework that resulted from this effort.",
  acknowledgement = ack-nhfb,
  affiliation =  "IBM Corp., Rochester, MN, USA",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150J (Operating systems); C6120
                 (File organisation)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages); C6150J
                 (Operating systems)",
  corpsource =   "IBM Corp., Rochester, MN, USA",
  keywords =     "Abstract data types; abstract data types;
                 architecture; AS/400 operating system; C language; C++
                 language; Code change; code change; I/O support; IBM
                 Rochester; IBM Rochester laboratory; input-output
                 programs; laboratory; Object based programming; object
                 based programming; Object-oriented framework;
                 object-oriented framework; object-oriented languages;
                 object-oriented programming; OOD; RISC based; RISC
                 based architecture",
  thesaurus =    "Abstract data types; C language; Input-output
                 programs; Object-oriented languages; Object-oriented
                 programming",
  treatment =    "A Application",
}

@Article{Veldhuizen:1995:UCT,
  author =       "T. Veldhuizen",
  title =        "Using {C++} template metaprograms",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "4",
  pages =        "36--38, 40, 42--43",
  month =        may,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Template metaprograms can generate useful code when
                 interpreted by the compiler, which results in large
                 speed increases for many applications. A simple example
                 that generates factorials at compile time is presented.
                 Although this technique might seem like just a cute C++
                 trick, it becomes powerful when combined with normal
                 C++ code. In this hybrid approach, source code contains
                 two programs: the normal C++ runtime program, and a
                 template metaprogram that runs at compile time.
                 Template metaprograms can generate useful code when
                 interpreted by the compiler, such as a massively
                 inlined algorithm-that is, an implementation of an
                 algorithm that works for a specific input size, and has
                 its loops unrolled. This results in large speed
                 increases for many applications. The article presents a
                 simple template metaprogram that generates a bubble
                 sort algorithm and its performance is analysed.",
  acknowledgement = ack-nhfb,
  affiliation =  "Waterloo Univ., Ont., Canada",
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  corpsource =   "Waterloo Univ., Ont., Canada",
  keywords =     "algorithm; bubble sort; Bubble sort algorithm; C
                 language; C++; C++ runtime program; C++ template
                 metaprograms; Compiler interpretation; compiler
                 interpretation; Factorials; factorials; Hybrid
                 approach; hybrid approach; increases; Massively inlined
                 algorithm; massively inlined algorithm; Normal C++
                 code; normal C++ code; object-oriented; object-oriented
                 languages; program compilers; program interpreters;
                 programming; runtime program; speed; Speed increases",
  thesaurus =    "C language; Object-oriented languages; Object-oriented
                 programming; Program compilers; Program interpreters",
  treatment =    "P Practical",
}

@Article{Trinoski:1995:CAD,
  author =       "S. Trinoski and D. Schmidt",
  title =        "Comparing alternative distributed programming
                 techniques",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "4",
  pages =        "44--53",
  month =        may,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "Various programming techniques for developing
                 distributed applications are examined and evaluated.
                 The requirements for a representative distributed
                 application in the financial services domain have been
                 outlined in previous articles. This application enables
                 investment brokers to query the price of a stock as
                 well as to buy shares of stock. The quote service that
                 maintains the current stock prices is physically remote
                 from brokers, who work in geographically distributed
                 sites. Therefore, our application must work
                 efficiently, robustly, and securely across various wide
                 area (WAN) and local area (LAN) networks. We selected
                 the stock trading application because the issues raised
                 by analyzing, designing, and implementing it are
                 representative of the issues that arise when developing
                 many other types of distributed applications.",
  acknowledgement = ack-nhfb,
  affiliation =  "Hewlett--Packard Co., Chelmsford, MA, USA",
  classcodes =   "C7120 (Financial computing); C6115 (Programming
                 support); C5620W (Other computer networks); C5620L
                 (Local area networks); C6110J (Object-oriented
                 programming); C6150N (Distributed systems software)",
  classification = "C5620L (Local area networks); C5620W (Other computer
                 networks); C6110J (Object-oriented programming); C6115
                 (Programming support); C6150N (Distributed systems
                 software); C7120 (Financial computing)",
  corpsource =   "Hewlett--Packard Co., Chelmsford, MA, USA",
  keywords =     "application generators; area networks; Brokers;
                 brokers; C language; current stock; Current stock
                 prices; development; distributed applications;
                 Distributed applications development; Distributed
                 programming techniques; distributed programming
                 techniques; electronic trading; Financial services
                 domain; financial services domain; Geographically
                 distributed sites; geographically distributed sites;
                 Investment brokers; investment brokers; local; Local
                 area networks; local area networks; object-oriented
                 languages; Physically remote quote service; physically
                 remote quote service; prices; programming; stock
                 markets; Stock price querying; stock price querying;
                 Stock shares buying; stock shares buying; Stock trading
                 application; stock trading application; Wide area
                 networks; wide area networks",
  thesaurus =    "Application generators; C language; Electronic
                 trading; Local area networks; Object-oriented
                 languages; Programming; Stock markets; Wide area
                 networks",
  treatment =    "P Practical",
}

@Article{Veldhuizen:1995:ET,
  author =       "T. Veldhuizen",
  title =        "Expression templates",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "5",
  pages =        "26--31",
  month =        jun,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The technique of expression templates is a powerful
                 and convenient alternative to C-style callback
                 functions. It allows logical and algebraic expressions
                 to be passed to functions as arguments, and inlined
                 directly into the function body. Expression templates
                 also solve the problem of evaluating vector and matrix
                 expressions in a single pass without temporaries.",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Syst. Design Eng., Waterloo Univ., Ont.,
                 Canada",
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support); C4140 (Linear algebra); C6120
                 (File organisation)",
  classification = "C4140 (Linear algebra); C6110J (Object-oriented
                 programming); C6115 (Programming support); C6120 (File
                 organisation)",
  corpsource =   "Dept. of Syst. Design Eng., Waterloo Univ., Ont.,
                 Canada",
  keywords =     "abstract data types; Algebraic expressions; algebraic
                 expressions; Arguments; arguments; C language; C-style
                 callback functions; Expression templates; expression
                 templates; expressions; libraries; logical; Logical
                 expressions; matrix; matrix algebra; Matrix
                 expressions; object-; object-oriented programming;
                 oriented languages; Single pass; single pass; software;
                 Vector expressions; vector expressions",
  thesaurus =    "Abstract data types; C language; Matrix algebra;
                 Object-oriented languages; Object-oriented programming;
                 Software libraries",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Myers:1995:NUT,
  author =       "N. Myers",
  title =        "A new and useful technique: ``traits''",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "5",
  pages =        "32--35",
  month =        jun,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "The trait technique is useful immediately, on any
                 compiler that supports templates. It provides a
                 convenient way to associate related types, values, and
                 functions with a template parameter type without
                 requiring that they be defined as members of the type.
                 A simple language extension dramatically (and
                 upward-compatibly) extends the technique to allow
                 greater flexibility, even at runtime, at no cost in
                 convenience or efficiency.",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6115 (Programming
                 support); C6110J (Object-oriented programming); C6150C
                 (Compilers, interpreters and other processors)",
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support); C6120 (File organisation);
                 C6150C (Compilers, interpreters and other processors)",
  keywords =     "abstract data types; C language; compiler; Compiler;
                 functions; Functions; language extension; Language
                 extension; object-oriented languages; program
                 compilers; software libraries; Template parameter type;
                 template parameter type; Templates; templates; Trait
                 technique; trait technique; Types; types; Values;
                 values",
  thesaurus =    "Abstract data types; C language; Object-oriented
                 languages; Program compilers; Software libraries",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Peden:1995:OAA,
  author =       "J. H. Peden",
  title =        "Operator ()() for array of array (of array) class
                 access",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "7",
  number =       "5",
  pages =        "36--38, 40--41",
  month =        jun,
  year =         "1995",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  abstract =     "In their article, Barton and Nackman (1993) make a
                 case for using templates rather than inheritance for a
                 TMA class. I argue that, for a class implementing an
                 AofA, one should use templates and inheritance; an AofA
                 class defined using the inherent is-a relationship
                 (e.g., a 4D AofA is a 1D array of 3D arrays) will allow
                 us to access the elements of each dimension of the
                 class using operator()().",
  acknowledgement = ack-nhfb,
  affiliation =  "Dept. of Comput. Sci., Longwood Coll., Farmville, VA,
                 USA",
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  corpsource =   "Dept. of Comput. Sci., Longwood Coll., Farmville, VA,
                 USA",
  keywords =     "1D array; 3D; 3D arrays; AofA; Array of array; array
                 of array; arrays; C language; C++; data structures;
                 Inheritance; inheritance; languages; object oriented;
                 Object oriented programming; object-oriented;
                 object-oriented programming; Operator()();
                 operator()(); programming; Templates; templates; TMA
                 class",
  thesaurus =    "C language; Data structures; Inheritance;
                 Object-oriented languages; Object-oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Lajoie:1996:FOR,
  author =       "J. Lajoie",
  title =        "Function overload resolution: selection of the best
                 viable function",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "12--17, 56",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  corpsource =   "Staff Dev., IBM Canada Ltd., Ont., Canada",
  keywords =     "abstract data types; best viable function; C language;
                 C++; function name; function overload resolution;
                 implicit type conversions; object-oriented languages;
                 object-oriented programming; selection; viable function
                 parameter",
  treatment =    "P Practical",
}

@Article{Glass:1996:SAH,
  author =       "G. Glass",
  title =        "{STL} in action. Helper algorithms",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "18--21",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150E (General utility programs); C6115 (Programming
                 support); C6110J (Object-oriented programming)",
  keywords =     "algorithms; C language; C++ Standard Template Library;
                 efficiency; error-prone work; function; helper;
                 object-oriented; object-oriented languages; programmer
                 error; programming; software libraries; STL algorithms;
                 templatized nonmember; utility programs",
  treatment =    "P Practical",
}

@Article{Muller:1996:TRH,
  author =       "H. M. Muller",
  title =        "Ten rules for handling exception handling
                 successfully",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "22--36",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130 (Data handling techniques); C6110J
                 (Object-oriented programming)",
  keywords =     "block-local resource; C language; C++ language; call
                 stack; catch-block; constraint; exception handling;
                 object; object-oriented languages; object-oriented
                 programming; resource; resource acquisitions; resource
                 management; return statement; secure operations;
                 shut-down; states; subresources; throw-and-keep
                 resource; wrapping",
  treatment =    "P Practical",
}

@Article{Martin:1996:OPS,
  author =       "R. C. Martin",
  title =        "The open-closed principle [software maintenance]",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "37--43",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  keywords =     "C language; C++; changing requirements; classes;
                 design principle; extension; fixed abstractions;
                 functions; heuristics; methods; modification; modules;
                 new code addition; object-oriented; object-oriented
                 design; object-oriented languages; open-closed
                 principle; possible behaviour group; software entities;
                 software maintenance; subroutines; unbounded",
  treatment =    "P Practical",
}

@Article{Schmidt:1996:CDP,
  author =       "D. C. Schmidt",
  title =        "Connector. {A} design pattern for actively
                 initializing network services",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "46--50, 52--56",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "B6150P (Communication network design and planning);
                 B6150M (Protocols); B6210L (Computer communications);
                 C6155 (Computer communications software); C6150N
                 (Distributed systems software); C6110J (Object-oriented
                 programming); C5640 (Protocols)",
  corpsource =   "Washington Univ., St. Louis, MO, USA",
  keywords =     "Acceptor pattern; access protocols; active network
                 service; communication; communication software;
                 computer communications software; connection
                 establishment; connection-; connection-oriented network
                 services; connection-related processing; Connector
                 design pattern; decoupling; efficient software;
                 endpoints; extensible software; file transfer;
                 initialization; network; network service evolution;
                 object-oriented methods; object-oriented techniques;
                 operating systems; oriented protocols; passive;
                 reliable data delivery; remote login; reusability;
                 reusable; service processing; software; World Wide Web
                 resource access",
  treatment =    "P Practical",
}

@Article{Onion:1996:OPM,
  author =       "F. Onion",
  title =        "Object persistence in {MFC}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "57--60",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  keywords =     "abstract data types; class instances; CObject class;
                 data; library based runtime class; MFC; object
                 persistence; object-; object-oriented languages;
                 oriented programming; simple class hierarchy; STL
                 container class; structure; structures",
  treatment =    "P Practical",
}

@Article{Horstmann:1996:CCL,
  author =       "C. S. Horstmann",
  title =        "{C++} class libraries for numerical programming",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "61--64, 66",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C7310 (Mathematics computing); C6110J (Object-oriented
                 programming); C4140 (Linear algebra); C4190 (Other
                 numerical methods); C6140D (High level languages)",
  corpsource =   "San Jose State Univ., CA, USA",
  keywords =     "C language; C++ class libraries; computing; FORTRAN
                 LINPACK; Fourier transforms; IMSL Math Module; library;
                 linear algebra; M++; mathematical; mathematics; number
                 generators; numerical algorithms; numerical
                 programming; object-oriented; object-oriented
                 languages; probability distributions; problems;
                 programming; programming problems; random; random
                 number generation; software libraries; statistical
                 functions",
  treatment =    "P Practical",
}

@Article{Coplien:1996:HSP,
  author =       "J. O. Coplien",
  title =        "The human side of patterns",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "1",
  pages =        "73--74, 76--78, 80",
  month =        jan,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6140D (High level languages); C7100 (Business
                 and administration)",
  corpsource =   "Software Prod. Res. Dept., AT\&T Bell Labs.,
                 Naperville, IL, USA",
  keywords =     "architectural; architecture; business process;
                 considerations; object oriented practice; object-;
                 object-oriented languages; object-oriented methods;
                 organizational issues; organizational practice;
                 oriented programming; pattern language; process
                 patterns; recurring patterns; reengineering; software
                 architectures; system; systems re-engineering",
  treatment =    "P Practical",
}

@Article{Vlissides:1996:PHP,
  author =       "J. Vlissides",
  title =        "Protection. {I}. The {Hollywood} principle",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "14, 16--19",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming); C6130S (Data security)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "architectural artifacts; corruption; data; data
                 integrity; data protection; errors; file organisation;
                 file system design; frameworks; Hollywood principle;
                 implementation artifacts; integrity maintenance; object
                 oriented programming; object-oriented; programming;
                 security of data",
  treatment =    "P Practical",
}

@Article{Leary:1996:CEH,
  author =       "S. Leary",
  title =        "{C++} exception handling in multithreaded programs",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "20--31",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150J (Operating systems); C6130
                 (Data handling techniques)",
  corpsource =   "Dresser-Wayne Ind., USA",
  keywords =     "C language; C++; exception handling; exception-aware
                 thread class; exception-safe programming; lightweight
                 threads; multiprogramming; multitasking; multithreaded
                 programs; object oriented programming; object-;
                 object-oriented programming; operating; oriented
                 languages; OS/2; reusable C++ classes; software
                 reusability; Solaris; systems; systems (computers);
                 thread manager class; thread-safe reference counting
                 class; Windows 95; Windows NT",
  treatment =    "P Practical",
}

@Article{Kamahele:1996:SCC,
  author =       "M. L. Kamahele",
  title =        "{ShMem} --- a {C++} class library for managing objects
                 in shared memory",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "32--39, 60",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6140D (High level
                 languages); C6110J (Object-oriented programming); C6115
                 (Programming support)",
  corpsource =   "Hughes Network Syst. Inc., Germantown, MD, USA",
  keywords =     "C language; C++; class library; lifetimes; machine
                 crashes; multiple threads; object management;
                 object-oriented; object-oriented languages; process;
                 programming; shared memory; shared memory systems;
                 ShMem; software libraries; storage allocation; storage
                 management; thread-safe class library",
  treatment =    "P Practical",
}

@Article{Fitzpatrick:1996:CSC,
  author =       "J. Fitzpatrick",
  title =        "A case study: converting {C} programs to {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "40--45, 63",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  corpsource =   "Red Mountain Corp., USA",
  keywords =     "C; C language; C++; case study; compilers; design;
                 function prototyping; graphics adapter test program;
                 object; object-oriented; object-oriented languages;
                 oriented programming; program compilers; program
                 interpreters; programming; software projects; type
                 checking",
  treatment =    "P Practical",
}

@Article{Cargill:1996:OJC,
  author =       "T. Cargill",
  title =        "An overview of {Java} for {C++} programmers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "46--49",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  keywords =     "C language; C++; design philosophy; Internet; Java;
                 object; object oriented language; object-oriented;
                 object-oriented languages; oriented programming;
                 programming; Sun Microsystems; World Wide Web browser",
  treatment =    "P Practical",
}

@Article{Schmidt:1996:CAPa,
  author =       "D. C. Schmidt and S. Vinoski",
  title =        "Comparing alternative programming techniques for
                 multithreaded servers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "50--59",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems software); C6110J (Object-
                 oriented programming); C6160 (Database management
                 systems (DBMS)); C6140D (High level languages)",
  corpsource =   "Washington Univ., St. Louis, MO, USA",
  keywords =     "applications; C; C language; C++; client-server
                 systems; CORBA; database management; desktop client;
                 financial data processing; investment brokers;
                 languages; multithreaded servers; multithreaded
                 systems; object-oriented; object-oriented programming;
                 programming; query processing; stock prices; stock
                 quote database; synchronization; systems; wrappers",
  treatment =    "P Practical",
}

@Article{Barton:1996:AD,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Automatic differentiation",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "61--63",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C7310 (Mathematics computing); C4160 (Numerical
                 integration and differentiation); C6110J
                 (Object-oriented programming)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "analytic differentiation; automatic differentiation; C
                 language; C++; derivatives; differentiation;
                 expressions; mathematics computing; multicomponent
                 types; numbers; object oriented programming; object-;
                 object-oriented programming; operator overloading;
                 operators; oriented languages; overloaded arithmetic;
                 Rall; value",
  treatment =    "P Practical",
}

@Article{Jordan:1996:OOQ,
  author =       "D. Jordan",
  title =        "{OQL}: the {Object Query Language}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "2",
  pages =        "64--66, 71--73",
  month =        feb,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6160J (Object-oriented
                 databases); C6160D (Relational databases)",
  corpsource =   "AT\&T Bell Labs., USA",
  keywords =     "abstraction; functional query language; languages;
                 level; Object Database Management Group; object
                 oriented database; Object Query Language;
                 object-oriented databases; object-oriented languages;
                 ODMG model; OQL; query; relational database; relational
                 databases; SQL",
  treatment =    "P Practical",
}

@Article{Jameson:1996:MPL,
  author =       "K. Jameson",
  title =        "Multiplatform productivity lessons",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "CPS4--CPS6, CPS9",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C0310F (Software development management); C6110B
                 (Software engineering techniques); C6115 (Programming
                 support)",
  keywords =     "multiplatform development; multiplatform productivity;
                 programming environments; software development
                 environment; software development management; software
                 engineering; software tools",
  treatment =    "P Practical",
}

@Article{Jeghers:1996:GDC,
  author =       "M. Jeghers",
  title =        "{GUI} development with cross platform toolkits",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "CPS7--CPS9",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6180G (Graphical user interfaces); C6115 (Programming
                 support); C6110B (Software engineering techniques)",
  keywords =     "application program interfaces; cross platform
                 toolkits; graphical user; graphical user interfaces;
                 GUI development; interface; least common denominator
                 functionality; software portability; software tools;
                 style guide compliance",
  treatment =    "P Practical",
}

@Article{Martin:1996:LSP,
  author =       "R. C. Martin",
  title =        "The {Liskov} substitution principle",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "14, 16--17, 20--23",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  keywords =     "abstract base classes; abstract polymorphic
                 interfaces; abstraction; C language; C++; design rules;
                 functions; hierarchies; inheritance; Liskov
                 substitution principle; object-; object-oriented
                 languages; object-oriented programming; Open-Closed
                 principle; oriented methods; polymorphism; statically
                 typed languages; virtual",
  treatment =    "P Practical",
}

@Article{Reeves:1996:CE,
  author =       "J. W. Reeves",
  title =        "Coping with exceptions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "24--35",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6130 (Data handling techniques)",
  keywords =     "ANSI ISO C++ committee; ANSI standards; C language;
                 C++ standard; exception handling; feature set; ISO;
                 nonexception handling code; object oriented
                 programming; object-oriented; object-oriented
                 languages; programming; software standards; standard
                 libraries; standards",
  treatment =    "P Practical",
}

@Article{Forguson:1996:PMD,
  author =       "D. Forguson",
  title =        "Programming with the {MFC} document template
                 architecture",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "36--41",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6180G (Graphical user interfaces); C6130D (Document
                 processing techniques); C6110J (Object-oriented
                 programming); C6115 (Programming support)",
  corpsource =   "Open Syst. Group, St. Louis, MO, USA",
  keywords =     "document handling; document type registration; drag;
                 drop; graphical user interfaces; management systems;
                 MFC document template architecture; object-; oriented
                 programming; programming; reusable components; software
                 reusability; user interface; user interfaces; word
                 processing",
  treatment =    "P Practical",
}

@Article{Hamilton:1996:RBO,
  author =       "J. Hamilton",
  title =        "Reusing binary objects with {DirectToSOM C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "42--51",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support); C6110B (Software engineering
                 techniques); C6150C (Compilers, interpreters and other
                 processors); C6140D (High level languages)",
  corpsource =   "IBM Canada Ltd., Ont., Canada",
  keywords =     "binary objects; C language; C++ class libraries; class
                 library; compatibility; compilers; DirectToSOM C++;
                 object-oriented programming; program compilers;
                 release-to-release binary; software libraries; software
                 reusability; vendors",
  treatment =    "P Practical",
}

@Article{Box:1996:CSP,
  author =       "D. Box",
  title =        "Com smart pointers also considered harmful",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "54--57",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation); C6150C
                 (Compilers, interpreters and other processors)",
  keywords =     "abstract data types; C language; C++; class library;
                 COM interface pointers; Com smart pointers;
                 exception-safe firewall; IUnknown; object oriented
                 language; object-oriented languages; object-oriented
                 programming; program control structures; smart
                 pointers; SmartInterface class",
  treatment =    "P Practical",
}

@Article{Onion:1996:DDS,
  author =       "F. Onion and A. Harrison",
  title =        "Dynamic data structure serialization in {MFC}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "58--62",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6140D (High level
                 languages)",
  keywords =     "C language; data structure serialization; data
                 structures; dynamic data structure; MFC; object
                 reconstruction; pointer storage",
  treatment =    "P Practical",
}

@Article{Horstmann:1996:JPS,
  author =       "C. S. Horstmann",
  title =        "{Java} programming with {Sun's Java} development kit",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "3",
  pages =        "63--70",
  month =        mar,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors); C6150G (Diagnostic, testing,
                 debugging and evaluating systems); C6115 (Programming
                 support); C5620W (Other computer networks); C6180G
                 (Graphical user interfaces)",
  corpsource =   "San Jose State Univ., CA, USA",
  keywords =     "compiler; debugging; debugging tools; graphical user
                 interface; graphical user interfaces; high level
                 languages; Internet; Java; network; object-oriented
                 programming; object-oriented programming language;
                 program; program compilers; programming; software
                 development kit; software tools; Sun Microsystems;
                 World Wide Web",
  treatment =    "P Practical",
}

@Article{Vlissides:1996:PMP,
  author =       "J. Vlissides",
  title =        "Protection: membership has its privileges",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "11--13, 16--18, 28",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6130G
                 (Groupware)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "design; file organisation; file system protection;
                 groups; groupware; mediator pattern; membership;
                 object-oriented programming; patterns; users",
  treatment =    "P Practical",
}

@Article{Meyers:1996:SP,
  author =       "S. Meyers",
  title =        "Smart pointers. {I}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "19--23",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  keywords =     "assignment; built in pointers; C language; C++;
                 construction; copying; data structures; dereferencing;
                 destruction; object-oriented languages; pointer
                 behavior; smart pointers",
  treatment =    "P Practical",
}

@Article{VanLoon:1996:PMS,
  author =       "R. {Van Loon}",
  title =        "The power of multimedia. Strengthen your applications
                 to power multimedia features",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "24--28",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130M (Multimedia); C7000 (Computer applications)",
  keywords =     "application; moving pictures; multimedia; multimedia
                 systems; music; power multimedia; speech",
  treatment =    "G General Review",
}

@Article{Cohen:1996:DIC,
  author =       "S. Cohen",
  title =        "Dynamic inheritance in {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "30--37",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "Orbotech Ltd., Yavne, Israel",
  keywords =     "C language; C+; extensibility; inheritance;
                 object-oriented programming; processing; production
                 image; reuse; software reusability",
  treatment =    "P Practical",
}

@Article{VanRooyen:1996:ACN,
  author =       "M. {Van Rooyen}",
  title =        "Alternative {C++}. New methods for solving old
                 problems",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "38--42",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C language; C++ classes; C++ issues; destruction;
                 lifetime; object ownership; object-oriented languages;
                 performance-critical systems",
  treatment =    "P Practical",
}

@Article{Forguson:1996:EMDa,
  author =       "D. Forguson",
  title =        "Extending the {MFC} document template architecture",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "43--53",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130D (Document processing techniques); C6110J
                 (Object-oriented programming)",
  corpsource =   "Open Syst. Group Inc., St. Louis, MO, USA",
  keywords =     "application-specific; document handling; document
                 template architecture; document templates; document
                 types; documents; Microsoft Foundation Class;
                 object-oriented programming; view classes",
  treatment =    "P Practical",
}

@Article{Schmidt:1996:CAPb,
  author =       "D. C. Schmidt and S. Vinoski",
  title =        "Comparing alternative programming techniques for
                 multithreaded {CORBA} servers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "56--66",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110P (Parallel
                 programming); C6140D (High level languages)",
  corpsource =   "Washington Univ., St. Louis, MO, USA",
  keywords =     "C language; complexity; distributed multithreaded
                 applications; multithreaded CORBA servers;
                 object-oriented programming; parallel; programming;
                 programming techniques",
  treatment =    "P Practical",
}

@Article{Barton:1996:HAI,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Hello {ANSI\slash ISO}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "68--70, 72--73",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "ANSI standards; ANSI/ISO C++ standard; ANSI/ISO
                 library; C language; C++; class; ISO standards;
                 languages; library; multiple platforms;
                 object-oriented",
  treatment =    "P Practical",
}

@Article{Glass:1996:USS,
  author =       "G. Glass",
  title =        "A universal streaming service",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "4",
  pages =        "74--76, 81--83",
  month =        apr,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6115 (Programming support)",
  keywords =     "C language; C++ toolkit; interprocess communication
                 mechanism; object-oriented programming; persistent;
                 software tools; STL; transportable; universal streaming
                 service; USS",
  treatment =    "P Practical",
}

@Article{Cohen:1996:LPC,
  author =       "S. Cohen",
  title =        "Lightweight persistence in {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "22--32",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6160J (Object-
                 oriented databases); C6150C (Compilers, interpreters
                 and other processors); C6150J (Operating systems)",
  corpsource =   "Orbotech Ltd., Yavne, Israel",
  keywords =     "(computers); C language; C++ compiler; languages;
                 lightweight persistence; object-oriented;
                 object-oriented databases; object-oriented DBMS;
                 object-oriented programming; operating system
                 platforms; operating systems; portability; program
                 compilers; software; software portability; standard C++
                 strategies",
  treatment =    "P Practical",
}

@Article{Moth:1996:LC,
  author =       "C. Moth",
  title =        "Lightweight classes",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "33--39",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6160J (Object-oriented databases); C6120 (File
                 organisation)",
  keywords =     "abstract data types; C data types; C language; C
                 language database libraries; C++; C++ database; code;
                 lightweight classes; object database; object
                 serialization code maintenance; object-oriented design
                 technique; object-oriented methods; object-oriented
                 programming; programming; software; software libraries;
                 standardisation; standardization; standards; systems",
  treatment =    "P Practical",
}

@Article{Linenbach:1996:IRB,
  author =       "T. Linenbach",
  title =        "Implementing reusable binary association in {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "40--47, 51",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques)",
  corpsource =   "Sagent Technol., Menlo Park, CA, USA",
  keywords =     "C language; C++ language; object; object-oriented
                 programming; one-to-many; one-to-one relationships;
                 program modification; relationships; reusability;
                 reusable binary association; software; software
                 functionality; software projects",
  treatment =    "P Practical",
}

@Article{Onion:1996:DDE,
  author =       "F. Onion and A. Harrison",
  title =        "Dialog data exchange in {MFC}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "48--51",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6180G (Graphical user interfaces); C6115 (Programming
                 support); C6110J (Object-oriented programming)",
  keywords =     "automated transfer; ClassWizard code generator; DDV
                 mechanism; DDX; dialog box; dialog data exchange;
                 formatting; graphical user interfaces; MFC;
                 object-oriented programming; software tools; user
                 interface management systems; validation of data",
  treatment =    "P Practical",
}

@Article{Reeves:1996:ESC,
  author =       "J. Reeves",
  title =        "Exceptions and {Standard C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "56--59, 62--64",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "San Jose State Univ., CA, USA",
  keywords =     "C language; error conditions; exception handling;
                 exception-based language; handling exceptions;
                 object-oriented languages; object-oriented programming;
                 Standard C++; throwing exceptions",
  treatment =    "P Practical",
}

@Article{Koenig:1996:IAS,
  author =       "A. Koenig",
  title =        "Inheritance, assignment, and slicing",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "71--72",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  keywords =     "assignment; copying a value; inheritance;
                 object-oriented programming; slicing",
  treatment =    "P Practical",
}

@Article{Lajoie:1996:MMR,
  author =       "J. Lajoie",
  title =        "The memory model-type representations",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "5",
  pages =        "73--76, 81--83",
  month =        may,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming); C6120 (File organisation)",
  corpsource =   "IBM Canada Ltd., Canada",
  keywords =     "C language; C++ memory model; C++ object model; C++
                 standard committee; data structures; memory model-type
                 representations; object-oriented languages; storage
                 layout",
  treatment =    "P Practical",
}

@Article{Vlissides:1996:KS,
  author =       "J. Vlissides",
  title =        "To kill a singleton",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "10, 12, 16--19",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "abstract data types; C language; client; deletion;
                 design; file system; file system users; global point of
                 access; multiple instances; object-oriented languages;
                 object-oriented programming; program; singleton class;
                 singleton instances; singleton pattern; static Instance
                 operation; user object; user objects",
  treatment =    "P Practical",
}

@Article{Meyers:1996:SPN,
  author =       "S. Meyers",
  title =        "Smart pointers, nullness, and type conversions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "20--23",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  keywords =     "abstract data types; C language; C++ language; dumb
                 pointers; nullness; object-oriented languages;
                 object-oriented programming; OOP; program control
                 structures; smart pointer classes; type conversions",
  treatment =    "P Practical",
}

@Article{Lakos:1996:LCSa,
  author =       "J. Lakos",
  title =        "Large-scale {C++} software design. 1. {Mentor
                 Graphics} experiences using {C++} for large systems",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "26--37",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6110B (Software engineering
                 techniques)",
  keywords =     "atomic unit; C language; C++ software; complete
                 abstraction; cyclic link time dependencies; design
                 time; development; IsA; large scale C++ software
                 design; large systems; logical; logical design
                 entities; logical entities; maintainability; Mentor
                 Graphics experiences; object-oriented; object-oriented
                 languages; physical dependencies; physical design
                 rules; programming; relationships; small project
                 experience; software reusability",
  treatment =    "P Practical",
}

@Article{Lippman:1996:VO,
  author =       "S. Lippman",
  title =        "The varieties of object",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "38--50",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  keywords =     "aggregation; C language; C++; data encapsulation;
                 encapsulation; features; inheritance; languages;
                 object; object-oriented; object-oriented programming;
                 program performance",
  treatment =    "T Theoretical or Mathematical",
}

@Article{Mueller:1996:OPL,
  author =       "T. R. Mueller",
  title =        "Overcoming the problems in a large scale {C++}
                 project. {AT\&T's} gamble with {C++} as a primary
                 programming language",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "51--52",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C7410F (Communications computing); C0310P (DP
                 personnel management); C0310F (Software development
                 management); C6110J (Object-oriented programming);
                 C6140D (High level languages); C0220 (Computing
                 education and training)",
  corpsource =   "AT\&T Bell Labs., Columbus, OH, USA",
  keywords =     "architecture; C language; C++; C++ usage; Columbus
                 AT\&T location; examples; expertise; human resource
                 management; in-house courses; informal seminars;
                 languages; large scale C++ project; management;
                 management support; object-oriented; object-oriented
                 programming; personnel; primary programming language;
                 programming; project; reliability; risks; software
                 development management; staff; switching system
                 building; telecommunication computing; training",
  treatment =    "P Practical",
}

@Article{Fitzpatrick:1996:RGT,
  author =       "J. Fitzpatrick",
  title =        "Redesigning a graphics test program using {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "54--60",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "C; C language; C++; code size; computer graphic
                 equipment; computers; graphics adapter cards; graphics
                 test program; IBM compatible; IBM-PC compatible;
                 machines; MS-DOS program; object oriented methods;
                 object-oriented; object-oriented languages; operating
                 systems (computers); program; programming; reusability;
                 rewriting; software; software modularity; software
                 reuse; system reengineering; systems re-engineering",
  treatment =    "P Practical",
}

@Article{Martin:1996:DIP,
  author =       "R. C. Martin",
  title =        "The {Dependency Inversion Principle}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "61--66",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "bad software design; C language; C++; Dependency
                 Inversion Principle; DIP; inheritance; Liskov
                 Substitution Principle; LSP; object oriented; object-;
                 object-oriented languages; object-oriented programming;
                 OCP; Open Closed Principle; oriented methods;
                 programming; public",
  treatment =    "P Practical",
}

@Article{Forguson:1996:DVC,
  author =       "D. Forguson",
  title =        "Developing the view component in {MFC}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "67--74, 76",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130D (Document processing techniques); C6180 (User
                 interfaces); C6110J (Object-oriented programming)",
  corpsource =   "Open Syst. Group Inc., St. Louis, MO, USA",
  keywords =     "application-specific classes; bitmaps; classes;
                 document; document classes; document handling; logical;
                 MFC; MFC CView class; Microsoft Foundation Class;
                 object oriented; object-oriented programming;
                 persistent data store; programming; reusability;
                 software; software reuse; spreadsheets; template
                 architecture; text; user interface; user interfaces;
                 view; view component",
  treatment =    "P Practical",
}

@Article{Barton:1996:WCC,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "While (converting to {C++}) use iterators",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "6",
  pages =        "77--78, 83, 87",
  month =        jun,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "algorithms-; ANSI ISO C++ standard; ANSI standards; C
                 language; C++; containers; finite-element; HP; input
                 file; ISO standards; iterator-container paradigm;
                 iterators; languages; mesh; object oriented
                 programming; object-oriented; object-oriented
                 programming; prototype; SafeSTL; software libraries;
                 software standards; standard library; STL",
  treatment =    "P Practical",
}

@Article{Henkel:1996:ECL,
  author =       "S. Henkel and W. Dangelmaier",
  title =        "Evaluating class libraries for interprocess
                 communication",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "21--29",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems software); C6110J (Object-
                 oriented programming); C6115 (Programming support)",
  keywords =     "ACE; C language; C++ class libraries; compilation;
                 distributed processing; functionality; gcc 2.7.0; GNU;
                 interprocess communication; Net.h++; object-oriented;
                 performance; programming; Socket++; software libraries;
                 software reviews; Solaris 2.4; SPARCstations; Sun; Sun
                 CC 4.0.1",
  treatment =    "P Practical; R Product Review",
}

@Article{Kreft:1996:IST,
  author =       "K. Kreft and A. Langer",
  title =        "Iterators in the {Standard Template Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "31--37",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6110B (Software engineering
                 techniques)",
  keywords =     "C language; C++; extensible framework; generic
                 programming; iterator adaptors; iterator base classes;
                 iterator categories; iterator tags; joint ISO/ANSI
                 standards; language; object-oriented; object-oriented
                 languages; programming; software libraries; Standard
                 C++ Library; Standard Template Library; STL iterators",
  treatment =    "P Practical",
}

@Article{Harrison:1996:EPO,
  author =       "T. H. Harrison and D. C. Schmidt",
  title =        "Evaluating the performance of {OO} network programming
                 toolkits",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "39--46",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6150N
                 (Distributed systems software); C6110P (Parallel
                 programming)",
  corpsource =   "Dept. of Comput. Sci., Washington Univ., St. Louis,
                 MO, USA",
  keywords =     "Broker Architecture; Common Object Request; computing;
                 data; distributed object; high speed networks; IPC
                 mechanisms; low speed networks; object-oriented
                 methods; object-oriented programming; OO network
                 programming toolkits; open standard; parallel
                 programming; performance issues; software performance
                 evaluation; software standards; transfer",
  treatment =    "P Practical",
}

@Article{Schmidt:1996:CAPc,
  author =       "D. C. Schmidt and S. Vinoski",
  title =        "Comparing alternative programming techniques for
                 multithreaded {CORBA} servers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "47--56",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6150N
                 (Distributed systems software); C5690 (Other data
                 communication equipment and techniques); C6110P
                 (Parallel programming)",
  corpsource =   "Washington Univ., St. Louis, MO, USA",
  keywords =     "alternative programming techniques; C; C++ wrappers;
                 concurrency model; CORBA; multithreaded CORBA;
                 multithreaded stock quote servers; network servers;
                 object-oriented programming; parallel; programming;
                 servers; thread per request; thread per session model;
                 thread pool",
  treatment =    "P Practical",
}

@Article{Onion:1996:CRC,
  author =       "F. Onion and A. Harrison",
  title =        "{Chain of Responsibility} and command targets",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "57--59, 62--63",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6150E (General
                 utility programs); C6150J (Operating systems); C6120
                 (File organisation); C6140D (High level languages)",
  keywords =     "abstract data types; abstractions; application program
                 interfaces; behavior encapsulation; C; C++; CCmdTarget
                 class; Chain of; classes; generic command; language;
                 message routing; messaging architecture; MFC; MFC
                 programming; object encapsulation; object-oriented;
                 object-oriented languages; programming; Responsibility
                 pattern; targets; Windows API",
  treatment =    "P Practical",
}

@Article{Reeves:1996:TGE,
  author =       "J. W. Reeves",
  title =        "Ten guidelines for exception specification",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "7",
  pages =        "64--68, 70, 88",
  month =        jul,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6140D (High level languages); C6130 (Data
                 handling techniques)",
  keywords =     "application level; bad-; C language; C++; exception;
                 exception handling; exception specifications;
                 exceptions; formal specification; functional
                 programming; functions; handler(); languages;
                 object-oriented; object-oriented programming;
                 programming guidelines; public interface functions;
                 terminate-; throw(); type definition;
                 unexpected-handler(); valid; virtual functions",
  treatment =    "P Practical",
}

@Article{Alicea:1996:UUS,
  author =       "H. Alicea and G. Glass",
  title =        "Using the universal streaming service with {CORBA}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "12--19",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6150N
                 (Distributed systems software); C6120 (File
                 organisation)",
  corpsource =   "Manugistics, Rockville, MD, USA",
  keywords =     "abstract data types; business object; call-by-;
                 client-server systems; Common Object Request Broker
                 Architecture; complex data objects; CORBA; CORBA
                 clients; CORBA Request handle; distributed systems
                 development; interface definition language;
                 interprocess communication; IONA Orbix; lightweight;
                 mechanism; models; network distribution; object
                 classes; object-oriented; opaque data types;
                 pass-by-value; persistent transportable objects;
                 programming; servers; software libraries; standard; STL
                 containers; template library; universal streaming
                 service; value parameter",
  treatment =    "P Practical",
}

@Article{Vissides:1996:TO,
  author =       "J. Vissides",
  title =        "The trouble with {Observer}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "20--24",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6180 (User interfaces); C6130 (Data
                 handling techniques)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Yorktown Heights,
                 NY, USA",
  keywords =     "C++ language; data encapsulation; data presentations;
                 definitive information; design patterns;
                 interface/application data separation; interfaces;
                 model-view-controller; object-oriented programming;
                 observer object; Observer pattern; partitioning;
                 querying; subject object; updating; user",
  treatment =    "P Practical",
}

@Article{Meyers:1996:SPA,
  author =       "S. Meyers",
  title =        "Smart pointers: automating inheritance and const
                 conversions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "25--27",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation)",
  keywords =     "compilers; const conversions; conversion operator;
                 data conversion; dumb pointer emulation; implicit;
                 inheritance; inheritance relationships; instantiated
                 member function; member function templates;
                 object-oriented programming; smart pointer classes;
                 subroutines; type conversion operators",
  treatment =    "P Practical",
}

@Article{White:1996:ADU,
  author =       "R. G. White",
  title =        "Advantages and disadvantages of unique representation
                 patterns",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "28--35",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6110B (Software engineering
                 techniques)",
  keywords =     "copy-on-write objects; data structures; design
                 patterns; dynamic object creation; equality comparison;
                 large objects; memory cost; memory usage;
                 multiple-client access; object-oriented programming;
                 oriented software; processing time; reduction;
                 reusability; reusable object-; singleton pattern;
                 software; storage management; unique representation
                 patterns",
  treatment =    "P Practical",
}

@Article{Gautier:1996:VR,
  author =       "P. Gautier",
  title =        "Visitors revisited",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "36--39, 42--45",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6110B (Software engineering
                 techniques); C6115 (Programming support)",
  corpsource =   "Thomson-CSF, Colombes, France",
  keywords =     "abstract data types; applications programming;
                 argument type; extension; frameworks;
                 inheritance-based; libraries; library class
                 functionality; method selection; object; object-based
                 programming; object-oriented programming; operation
                 definition; operation representation; reusable classes;
                 software; software reusability; structure elements;
                 template-based approach; triple-dispatch visitor;
                 visitor; visitor pattern",
  treatment =    "P Practical",
}

@Article{Bulka:1996:PCS,
  author =       "D. Bulka",
  title =        "Performance and {C++}: separating myth from reality",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "46--54",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150N (Distributed systems
                 software)",
  keywords =     "C language; C++; coding guidelines; Communications
                 Server for AIX; critical systems; evaluation; high
                 performance networking software; IBM; languages;
                 network operating systems; object oriented programming;
                 object-oriented; object-oriented programming; operating
                 system; performance; performance penalty; software
                 performance",
  treatment =    "P Practical",
}

@Article{Lakos:1996:LCSb,
  author =       "J. Lakos",
  title =        "Large-scale {C++} software design: physical hierarchy.
                 2. Effective testing, improved maintainability,
                 independent reuse",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "55--64",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques); C6150C (Compilers,
                 interpreters and other processors); C6140D (High level
                 languages)",
  corpsource =   "Mentor Graphics Corp., Warren, NJ, USA",
  keywords =     "C language; C++ software design-time; compile-time
                 coupling; compiled languages; component include;
                 encapsulation; graph; independent; large-scale C++
                 software design; large-scale systems; logical;
                 object-oriented languages; object-oriented programming;
                 physical dependencies; physical design; physical design
                 rules; physical hierarchy; program; program compilers;
                 relationships; run-time efficiency; separate
                 translation; software maintainability; software
                 maintenance; software reusability; software reuse;
                 software testing; testing; units",
  treatment =    "P Practical",
}

@Article{Koenig:1996:CIS,
  author =       "A. Koenig",
  title =        "Copying and insertion in {STL} algorithms",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "65--66",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130 (Data handling techniques); C6140D (High level
                 languages); C6110J (Object-oriented programming); C6115
                 (Programming support)",
  keywords =     "C language; C++ standard library; copy algorithm;
                 copying; data handling; data movement; insertion;
                 iterator adaptor; memory allocation; object-;
                 object-oriented languages; oriented programming;
                 software libraries; Standard Template Library; STL
                 algorithms; STL containers",
  treatment =    "P Practical",
}

@Article{Lajoie:1996:CMMa,
  author =       "J. Lajoie",
  title =        "The {C++} memory model. Pointer manipulations",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "8",
  pages =        "67--72",
  month =        sep,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6140D (High level
                 languages); C6110J (Object-oriented programming); C6130
                 (Data handling techniques)",
  keywords =     "C language; C++ memory model; C++ programs; C++
                 Standard; coding practices; Committee; computer
                 architectures; data handling; data structures;
                 efficient C++ implementations; languages;
                 object-oriented; pointer manipulations; software
                 standards",
  treatment =    "G General Review",
}

@Article{Coplien:1996:CP,
  author =       "J. O. Coplien",
  title =        "Code patterns",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "18--25",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support); C6110F (Formal methods)",
  corpsource =   "Software Production Res. Dept., Bell Lab., Naperville,
                 IL, USA",
  keywords =     "automated code; automatic programming; code patterns;
                 design pattern automation; generation; object-;
                 object-oriented methods; oriented programming",
  treatment =    "P Practical",
}

@Article{Lajoie:1996:CMMb,
  author =       "J. Lajoie",
  title =        "The {C++} memory model: new and delete operators",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "26--33, 44",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  corpsource =   "IBM Canada Lab., Canada",
  keywords =     "ANSI standards; ANSI/ISO C++ Standard Committee; C
                 language; C++ memory model; delete; ISO standards;
                 languages; new operator; object-oriented;
                 object-oriented programming; operator; software
                 standards",
  treatment =    "P Practical",
}

@Article{Lajoie:1996:CSC,
  author =       "J. Lajoie",
  title =        "The {C++ Standards Committee}'s sixth
                 year-organization and schedule update",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "30--31",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  keywords =     "ANSI standards; C language; C++ standards committees
                 sixth year; ISO standards; languages; object-oriented;
                 schedule update; software standards",
  treatment =    "G General Review",
}

@Article{Soukup:1996:QP,
  author =       "J. Soukup",
  title =        "Quality patterns",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "34--44",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110B (Software
                 engineering techniques); C6120 (File organisation)",
  corpsource =   "IBM Canada Lab., Canada",
  keywords =     "abstract data types; C language; code modularity;
                 modular design; object-oriented languages;
                 object-oriented programming; quality patterns;
                 reusability; reusable pattern library coding; software;
                 software architecture; software libraries",
  treatment =    "P Practical",
}

@Article{Soukup:1996:ACM,
  author =       "J. Soukup",
  title =        "Another controversy: managing groups of cooperating
                 classes",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "46--47",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6110B (Software engineering
                 techniques)",
  corpsource =   "Code Farms Inc., USA",
  keywords =     "abstract data types; application classes; cooperating
                 class management; dependency loops; engineering;
                 manager classes; object-; object-oriented programming;
                 oriented strategy; overlapping; pattern classes;
                 relations; software; software architecture",
  treatment =    "P Practical",
}

@Article{Vinoski:1996:DCD,
  author =       "S. Vinoski and D. C. Schmidt",
  title =        "Distributed callbacks and decoupled communication in
                 {CORBA}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "48--56, 77",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems software); C6110J (Object-
                 oriented programming)",
  corpsource =   "Hewlett--Packard's Distributed Comput. Program,
                 Chelmsford, MA, USA",
  keywords =     "client-server systems; client/server; concurrency
                 control; concurrency models; consumers; CORBA;
                 decoupled communication; decoupled peer-to-peer;
                 distributed callbacks; distributed object computing
                 systems; distributed stock quoting; multithreaded;
                 object-oriented; OMG Events object service;
                 programming; relationships; request communication;
                 response communication; server applications; suppliers;
                 systems",
  treatment =    "P Practical",
}

@Article{Forguson:1996:EMDb,
  author =       "D. Forguson",
  title =        "Extending the {MFC} document template architecture",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "57--65",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6130D (Document processing techniques); C6110J
                 (Object-oriented programming); C6120 (File
                 organisation); C6110B (Software engineering
                 techniques)",
  corpsource =   "Open Systems Group Inc., St. Louis, MO, USA",
  keywords =     "abstract data types; C++ classes; data selection;
                 default behavior; development; document; document
                 class; Foundation Class library; MFC document template
                 architecture extension; Microsoft; object-oriented
                 programming; reusability; reuse; software; text
                 editing; view class; window class; Windows application;
                 Windows clipboard; windows message; WinEdit; word
                 processing",
  treatment =    "P Practical",
}

@Article{Barton:1996:SEC,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Scientific and engineering {C++-is} this standard
                 input?",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "9",
  pages =        "66, 68--69",
  month =        oct,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C7400 (Engineering
                 computing); C4185 (Finite element analysis)",
  keywords =     "ANSI/ISO collection; C language; code; engineering
                 computing; finite element analysis; finite-element
                 meshes; FORTRAN; FORTRAN-like coding; input stream;
                 mesh; programs; scientific and engineering C++",
  treatment =    "A Application; P Practical",
}

@Article{Vlissides:1996:GGS,
  author =       "J. Vlissides",
  title =        "{Generation Gap} [software design pattern]",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "12, 14--18",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6120 (File organisation); C6115 (Programming
                 support)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "automatic code generation; automatic programming; C++
                 language; class; code encapsulation; data
                 encapsulation; encapsulation; generated code
                 modification; Generation Gap; inheritance;
                 modifications; object-oriented methods; object-oriented
                 programming; software design pattern; structural;
                 structured programming",
  treatment =    "P Practical",
}

@Article{Meyers:1996:RSP,
  author =       "S. Meyers",
  title =        "Refinements to smart pointers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "19--22",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming); C6140D (High level languages)",
  keywords =     "C language; C++ language; data structures; dumb
                 pointers; object-oriented languages; object-oriented
                 programming; refinements; smart pointers",
  treatment =    "P Practical",
}

@Article{Koenig:1996:CPC,
  author =       "A. Koenig",
  title =        "Containers and pointer comparisons",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "23--26",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming)",
  keywords =     "array elements; arrays; C language; C++ language; data
                 structures; documentation; implementation; languages;
                 less-than operator; less<T> template; library
                 containers; object-oriented; object-oriented
                 programming; order-based containers; ordered
                 comparison; pointer comparisons; portable; software
                 portability; standard-conforming C++ implementation",
  treatment =    "P Practical",
}

@Article{Kreft:1996:ISC,
  author =       "K. Kreft and A. Langer",
  title =        "Iterators in the {Standard C++ Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "27--30, 32",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages);
                 C6150C (Compilers, interpreters and other processors)",
  keywords =     "algorithm interfaces; ANSI standards; association; C
                 language; C++ compiler; compile-time deduction;
                 function; general-purpose; generic programming
                 techniques; ISO standards; ISO/ANSI standards
                 committee; iterative; iterator design; iterator traits;
                 Library; methods; nonclass types; object-oriented;
                 object-oriented languages; overloading; program
                 compilers; programming; software; software libraries;
                 Standard C++ Library; Standard Template; standards;
                 STL; type",
  treatment =    "P Practical",
}

@Article{Lindner:1996:DSH,
  author =       "M. P. Lindner",
  title =        "Designing for safe hashing. Implementing efficient
                 dynamic search structures",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "36--41",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6120 (File organisation); C6110J (Object-oriented
                 programming)",
  keywords =     "abstract data types; C++ code optimization; C++
                 compiler; C++ language; C++ Standard Template Library;
                 class; constructs; data integrity; data structures;
                 dynamic search structures; efficient; hash-fun class;
                 hash-stream; hashed data; hasher class; hashing
                 function design; indexing; object-; object-oriented
                 design; oriented programming; performance; problems;
                 public domain software; safety; search; software
                 libraries; STL; structures; syntax; table size;
                 type-safety",
  treatment =    "P Practical",
}

@Article{Lakos:1996:LCSc,
  author =       "J. Lakos",
  title =        "Large-scale {C++} software design: levelization,
                 insulation, and packages. 3. Avoiding excessive
                 compile- and link-time dependencies",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "42--56",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors)",
  corpsource =   "Mentor Graphics, Warren, NJ, USA",
  keywords =     "C language; compile-time dependencies; cyclic
                 link-time; dependencies; insulation; large-scale C++
                 software design; large-scale systems; levelization;
                 macro unit; macros; methods; object-oriented;
                 object-oriented programming; packages; physical design;
                 program compilers",
  treatment =    "P Practical",
}

@Article{Martin:1996:GOD,
  author =       "R. C. Martin",
  title =        "Granularity [object-oriented design]",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "57--62",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110F (Formal
                 methods)C6110B (Software engineering techniques)",
  keywords =     "change; engineering; granularity; large
                 object-oriented applications; large-scale systems;
                 macro; maintainable software; object-oriented design;
                 object-oriented methods; packages; release; reusable
                 software; robust; software; software engineering;
                 structure; vocabularies",
  treatment =    "P Practical",
}

@Article{Reeves:1996:EDC,
  author =       "J. W. Reeves",
  title =        "Exceptions and debugging [in {C++}]",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "8",
  number =       "10",
  pages =        "63--71",
  month =        nov # "-" # dec,
  year =         "1996",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150G (Diagnostic, testing, debugging and evaluating
                 systems); C6110J (Object-oriented programming); C6140D
                 (High level languages); C6130 (Data handling
                 techniques)",
  keywords =     "assert macro; C language; C++ exception handling
                 mechanism; C++ program debugging; development; error
                 handling; exception handling; fault; independently
                 developed components; logic errors; macros;
                 object-oriented; program debugging; programming;
                 programming philosophy; runtime errors; software;
                 software fault tolerance; tolerance",
  treatment =    "P Practical",
}

@Article{Coplien:1997:PL,
  author =       "J. O. Coplien",
  title =        "Pattern languages",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "15--21",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  corpsource =   "Dept. of Software Production Res., Bell Labs.,
                 Naperville, IL, USA",
  keywords =     "architectural; contexts; generativity; object-oriented
                 languages; pattern catalog; pattern languages; style",
  treatment =    "G General Review",
}

@Article{Onion:1997:FCF,
  author =       "F. Onion and A. Harrison",
  title =        "Framework class factories",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "22--24",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "abstract data types; C language; C++ application
                 frameworks; CDocTemplate class; class instantiation;
                 dynamic document object creation; file opening;
                 framework class factories; MacApp framework; MFC
                 framework; microcomputer applications; object-oriented
                 languages; object-oriented programming; templates; user
                 intervention; user-defined document; virtual
                 construction",
  treatment =    "P Practical",
}

@Article{Hansen:1997:HRC,
  author =       "M. Hansen",
  title =        "How to reduce code bloat from {STL} containers",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "34--41",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150C (Compilers, interpreters and
                 other processors); C6115 (Programming support)",
  keywords =     "3.1; adapter template; C language; C++ templates; code
                 bloat reduction; compile-time complexity; compiler;
                 components; design-time complexity; executable file
                 size; generated class; generic class; generic
                 programming; instantiation; Microsoft Windows;
                 object-oriented; object-oriented languages; program
                 compilers; programming; software libraries; Standard
                 Template Library; STL containers; template container",
  treatment =    "P Practical",
}

@Article{Martin:1997:JCC,
  author =       "R. C. Martin",
  title =        "Java and {C++}: a critical comparison",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "42--49",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6140D (High level languages); C6110J (Object-oriented
                 programming)",
  keywords =     "C language; C++ language; Java; language design
                 trade-offs; object-oriented languages",
  treatment =    "G General Review",
}

@Article{Jain:1997:ECC,
  author =       "P. Jain and D. C. Schmidt",
  title =        "Experiences converting a {C++} communication software
                 framework to {Java}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "50--66",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110B (Software engineering techniques); C6155
                 (Computer communications software); C6140D (High level
                 languages); C6110J (Object-oriented programming)",
  corpsource =   "Washington Univ., St. Louis, MO, USA",
  keywords =     "C language; C++ communication software framework;
                 computer communications software; engineering;
                 features; flexibility; Java programming; language;
                 language constructs; language features; object-;
                 object-oriented programming; object-oriented
                 programming language; oriented languages; portability;
                 reverse; run-time; semantics; simplicity; software
                 conversion; software libraries; software portability;
                 standard library components",
  treatment =    "A Application",
}

@Article{Glass:1997:JGL,
  author =       "G. Glass",
  title =        "The {Java Generic Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "1",
  pages =        "70--74",
  month =        jan,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6115 (Programming support); C6110J (Object-oriented
                 programming); C6140D (High level languages)",
  keywords =     "containers; design goals; development systems;
                 Internet; Internet distribution; Java Development Kit;
                 Java Generic Library; JGL; object-oriented languages;
                 reusable; reusable algorithms; software libraries;
                 software tools; Standard Template Library; STL design
                 philosophy",
  treatment =    "P Practical",
}

@Article{Stewart:1997:DEH,
  author =       "R. L. Stewart and J. Storey and D. Huang",
  title =        "Decentralized event handling",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "12--19",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6150N (Distributed systems software); C6110J (Object-
                 oriented programming)",
  keywords =     "callback mechanism; CORBA-based TMN; decentralized
                 event handling; distributed object-oriented
                 applications; distributed processing; dynamic control
                 flow configuration; Framework; inheritance; methods;
                 network; object-oriented; run-time; TCSI;
                 telecommunication network management;
                 telecommunications management; telephony; telephony
                 network; TMN",
  treatment =    "P Practical",
}

@Article{Kreft:1997:BIS,
  author =       "K. Kreft and A. Langer",
  title =        "Building an iterator for {STL} and the {Standard C++
                 Library}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "20--27",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages)",
  keywords =     "C language; compile-time; iterator; object oriented;
                 object oriented language; object-oriented;
                 object-oriented languages; polymorphism; program
                 compilers; programming; reusability; software; software
                 libraries; software reuse; Standard C++ Library; STL;
                 user-defined abstractions",
  treatment =    "P Practical",
}

@Article{Hamilton:1997:UDS,
  author =       "J. Hamilton",
  title =        "Using {Distributed SOM} with {DirectToSOM C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "28--36",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6150N (Distributed systems
                 software); C6150C (Compilers, interpreters and other
                 processors)",
  keywords =     "application writing; binary compatibility; C language;
                 C++ language semantics; C++ language syntax; C++
                 programming; class client; CORBA standards; DirectToSOM
                 C++; DirectToSOM C++ compilers; distributed C++;
                 distributed processing; Distributed SOM; IBM System
                 Object Model; independent object model; interlanguage
                 object sharing; language-; languages; Management Group
                 Common Object Request Broker standards; networks;
                 Object; object-oriented; object-oriented programming;
                 object-oriented programming languages; program
                 compilers; release-to-release; software standards",
  treatment =    "P Practical",
}

@Article{Schmidt:1997:OES,
  author =       "D. C. Schmidt and S. Vinoski",
  title =        "The {OMG Events Service}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "37--46",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C7120 (Financial computing); C6110J (Object-oriented
                 programming); C6110F (Formal methods); C6150N
                 (Distributed systems software)",
  keywords =     "changing stock; client-server systems; consumers;
                 decoupled communication; event data delivery; financial
                 data processing; inter-object; notifying stock quoter;
                 object-; object-oriented programming; OMG Common Object
                 Services Specification Volume 1.2; OMG Events Service;
                 oriented methods; stock markets; suppliers; values",
  treatment =    "P Practical",
}

@Article{Vlissides:1997:TL,
  author =       "J. Vlissides",
  title =        "Type laundering",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "47--52",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6120 (File organisation)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "abstract base class; abstract data types; C language;
                 design bug; domain-specific events; Event; features;
                 lost type information recovery; object-oriented
                 languages; object-oriented programming; storage
                 management; type laundering",
  treatment =    "P Practical",
}

@Article{Martin:1997:LS,
  author =       "R. C. Martin",
  title =        "Large-scale stability",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "54--60",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6110S (Software
                 metrics); C6110B (Software engineering techniques);
                 C6110F (Formal methods)",
  keywords =     "C language; conformance measurement; design pattern;
                 interdependence; large C++ applications; large-scale
                 stability; methods; metrics; object-oriented;
                 object-oriented design; object-oriented languages;
                 object-oriented programming; quality measurement;
                 software metrics; software quality",
  treatment =    "P Practical",
}

@Article{Barton:1997:GT,
  author =       "J. J. Barton and L. R. Nackman",
  title =        "Generating and transforming",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "2",
  pages =        "62--64",
  month =        feb,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Tue Mar 25 13:34:48 MST 1997",
  acknowledgement = ack-nhfb,
  classcodes =   "C6110J (Object-oriented programming); C6120 (File
                 organisation); C7490 (Computing in other engineering
                 fields); C7300 (Natural sciences computing); C4185
                 (Finite element analysis)",
  corpsource =   "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
  keywords =     "ANSI standards; C language; classes; computing; data
                 structure manipulation; data structures; engineering;
                 engineering programming; FORTRAN-formatted
                 finite-element mesh; input stream iterators; ISO
                 standards; mesh; mesh generation; natural sciences;
                 object-oriented; object-oriented languages;
                 programming; representation; scientific programming;
                 software standards; template-based ANSI/ISO
                 collection",
  treatment =    "P Practical",
}

@Article{Martin:1997:TAP,
  author =       "R. C. Martin and J. W. Newkirk and B. Rao",
  title =        "Taskmaster: an architecture pattern for {GUI}
                 applications",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "12--14, 16--23",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6180G (Graphical user interfaces); C6115
                 (Programming support); C6110J (Object-oriented
                 programming); C6110B (Software engineering
                 techniques)",
  keywords =     "graphical user interfaces; object-oriented
                 programming; software maintenance; software
                 reusability; user interface management systems;
                 Taskmaster; architecture pattern; GUI applications;
                 graphical user interface; object oriented design;
                 software maintenance; software reuse; system
                 requirements; data manipulation; software architecture;
                 high-level abstractions",
  treatment =    "P Practical",
}

@Article{Thompson:1997:TPC,
  author =       "P. Thompson and G. Bumgardner",
  title =        "{Threads.h++}: a portable {C++} library for
                 multithreaded programming",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "24--37",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6115 (Programming support); C6110J (Object-oriented
                 programming); C6150J (Operating systems); C6110B
                 (Software engineering techniques)",
  keywords =     "application program interfaces; C language;
                 multiprogramming; object-oriented languages;
                 object-oriented programming; software libraries;
                 software portability; synchronisation; Threads.h++;
                 portable C++ library; multithreaded programming;
                 application development; multiprocessor machines;
                 responsive performance; Web browsers; operating
                 systems; synchronization; low-level procedural API; C
                 language; thread creation; thread control;
                 object-oriented abstractions",
  treatment =    "P Practical",
}

@Article{Jakubik:1997:PPA,
  author =       "P. Jakubik",
  title =        "Patterns in practice: abstract client",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "38--44",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages)",
  keywords =     "abstract data types; C language; object-oriented
                 languages; object-oriented programming; abstract client
                 pattern; object oriented patterns; object interaction;
                 callbacks; C++ programming",
  treatment =    "P Practical",
}

@Article{Langer:1997:COO,
  author =       "A. Langer and K. Kreft",
  title =        "Combining object-oriented design and generic
                 programming",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "45--49, 69",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6115
                 (Programming support); C6140D (High level languages)",
  keywords =     "C language; data structures; object-oriented
                 languages; object-oriented programming; software
                 libraries; software reusability; object-oriented
                 design; generic programming; Standard C++ Library; data
                 structures; internationalization; stream input-
                 output",
  treatment =    "P Practical",
}

@Article{Onion:1997:MM,
  author =       "F. Onion",
  title =        "Multithreading in {MFC}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "50--53, 56",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6150J
                 (Operating systems); C6115 (Programming support)",
  keywords =     "application program interfaces; multiprogramming;
                 object-oriented programming; software libraries;
                 software tools; user interfaces; MFC; multithreaded
                 programming; Internet queries; remote database hits;
                 threads; API calls; Windows; software libraries; object
                 oriented programming; user interface",
  treatment =    "P Practical",
}

@Article{Reeves:1997:RE,
  author =       "J. W. Reeves",
  title =        "Reflections on exceptions",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "3",
  pages =        "57--65",
  month =        mar,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6130 (Data handling techniques)",
  keywords =     "C language; exception handling; object-oriented
                 languages; object-oriented programming; program
                 debugging; exception handling; debugging; Standard C++;
                 development environment; assert macros; object oriented
                 programming",
  treatment =    "P Practical",
}

@Article{Davis:1997:WMO,
  author =       "M. Davis",
  title =        "Well-mannered objects: tips on porting {C++} to Java",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "4",
  pages =        "14--21",
  month =        apr,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6140D (High
                 level languages); C6110B (Software engineering
                 techniques)",
  keywords =     "C language; client-server systems; object-oriented
                 languages; object-oriented programming; software
                 portability; C++ code porting; Java; turnaround time;
                 software portability; power; simplicity; World Wide Web
                 applets; client-server applications; Taligent; Unicode
                 Analytic package; JavaSoft; JDK 1.1; well-behaved
                 objects; object classes",
  treatment =    "P Practical",
}

@Article{Cochran:1997:DRC,
  author =       "G. Cochran and R. Weisz",
  title =        "Developing reusable code in the real world: process
                 and techniques",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "4",
  pages =        "22--31",
  month =        apr,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110B (Software engineering techniques); C6110J
                 (Object-oriented programming)",
  corpsource =   "The Windward Group, Los Gatos, CA, USA",
  keywords =     "object-oriented programming; software reusability;
                 reusable code development; object-oriented programming;
                 class hierarchies; reusable software; software
                 development group needs; investment; code analysis;
                 code design; code implementation",
  treatment =    "P Practical",
}

@Article{Sime:1997:GPM,
  author =       "J. Sime",
  title =        "Guarded pointers: moving smart pointers into
                 multithreaded systems",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "4",
  pages =        "32--41",
  month =        apr,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6120 (File organisation); C6110J (Object-oriented
                 programming); C6150N (Distributed systems software);
                 C6130 (Data handling techniques)",
  keywords =     "abstract data types; C listings; concurrency control;
                 data integrity; exception handling; multiprogramming;
                 object-oriented programming; safety; guarded pointers;
                 smart pointers; multithreaded systems; concurrency
                 control pattern; protection proxy pattern; protected
                 data resource; thread safety mechanisms; reference
                 count lock",
  treatment =    "P Practical",
}

@Article{Martin:1997:DPD,
  author =       "R. C. Martin",
  title =        "Design patterns for dealing with dual inheritance
                 hierarchies in {C++}",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "4",
  pages =        "42--48",
  month =        apr,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6140D (High level languages)",
  keywords =     "C language; inheritance; object-oriented languages;
                 object-oriented methods; object-oriented programming;
                 C++ design patterns; dual inheritance hierarchies;
                 object-oriented applications; separation of concerns;
                 orthogonal concepts; application-related problems;
                 pattern language; Rungs of a Dual Hierarchy;
                 Intelligent Children; Stairway to Heaven; RTTI
                 Visitor",
  treatment =    "P Practical",
}

@Article{Soukup:1997:IP,
  author =       "J. Soukup",
  title =        "Implementing patterns",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "4",
  pages =        "49--50",
  month =        apr,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Thu Apr 24 09:46:14 MDT 1997",
  acknowledgement = ack-nhfb,
  classification = "C6110J (Object-oriented programming); C6120 (File
                 organisation); C6110F (Formal methods); C6110B
                 (Software engineering techniques)",
  keywords =     "abstract data types; object-oriented methods; software
                 engineering; structural patterns; software design;
                 software architecture; high-level concepts;
                 communication; design patterns; object-oriented data
                 structures; inheritance; data organization; pointers;
                 arrays",
  treatment =    "P Practical",
}

@Article{Shur:1997:EIC,
  author =       "Jim Shur",
  title =        "Exploring Inner Classes in {Java} 1.1: As {Java}
                 matures, it begs comparison to the robustness of
                 {C++}. See how {JDK} 1.1's inner classes compare to
                 nested classes",
  journal =      j-C-PLUS-PLUS-REPORT,
  volume =       "9",
  number =       "5",
  pages =        "18--29, 68",
  month =        may,
  year =         "1997",
  CODEN =        "CRPTE7",
  ISSN =         "1040-6042",
  bibdate =      "Fri May 02 06:51:43 1997",
}