Last update:
Wed May 25 09:36:12 MDT 2022
G. Booch and
M. Vilot C++ library design . . . . . . . . . . . 10--14
C. S. Horstmann A first look at programming Windows with
C++/Views and Borland C++ . . . . . . . 15--18, 24
S. Druker `What's that compiler doing, anyway?'
--- virtual function overhead . . . . . 19--20
J. M. Coggins Why does this program run so long? . . . 21--24
D. Steinhoff Saber-C++ version 1.0 . . . . . . . . . 26--27, 30
G. Booch and
M. Vilot Object-oriented design-C++ class
categories . . . . . . . . . . . . . . . 6--10
B. Eckel Containers and iterators in C++ . . . . 12--13
A. Lane DOS/C++ --- application frameworks . . . 14--15
R. Brazille and
B. Leggett The Object Interface Library . . . . . . 18--20, 22, 24
J. Coplien Experience with CRC cards in AT&T . . . . 1, 4--6
G. Booch and
M. Vilot Object-oriented analysis and design . . 7--10
T. Cargill CRC cards (OO programming) . . . . . . . 11--13
G. Booch and
M. Vilot The object-oriented development process 8--11
I. Huneke Linking C with C++ . . . . . . . . . . . 12, 16
C. J. Van Wyk Simultaneous equations are your friends 14--16
J. M. Coggins Naming conventions in C++ libraries . . 17--21
J. P. LeJacq Education can you do better than C++? 1, 4--6
G. Booch and
M. Vilot Object-oriented design documents . . . . 8, 10--12
D. Saks ANSI C++ update: works in progress . . . 13--14, 16
C. Horstmann An in-depth look as Borland C++ . . . . 17--20
J. M. Coggins Best of \path|comp.lang.C++| --- much
ado about null . . . . . . . . . . . . . 21--24
J. Soukup Selecting a C++ library . . . . . . . . 1, 4--6
G. Booch and
M. Vilot Object-oriented design: physical design:
storage management . . . . . . . . . . . 7--10
D. Saks ANSI C++ update: works in progress . . . 11--14
C. Horstmann The object-based class library in
Borland C++ . . . . . . . . . . . . . . 15--18
J. M. Coggins Handling failed constructors gracefully 20--22
G. McCluskey An environment for template
instantiation . . . . . . . . . . . . . 1, 4--7
G. Booch and
M. Vilot Physical design: storage and management
libraries (OOP) . . . . . . . . . . . . 8--10
J. Soukup Memory-resident databases . . . . . . . 11--15
C. Skelly Getting a handle on the new-handler . . 16--18
J. M. Coggins An array of questions about arrays . . . 19--22
N. Hamsath Zortech C++ Developers Edition . . . . . 23--25
B. Stroustrup and
D. Lenkov Runtime type identification for C++ . . 32--42
S. C. Dewhurst Distributed abstract interfaces . . . . 44--50
J. Musser Extending streambufs: class logstrbuf
(OOP) . . . . . . . . . . . . . . . . . 51--55
S. Buroff and
R. Murray The C++ Oracle . . . . . . . . . . . . . 9--10
B. Eckel Virtual constructors. 2 . . . . . . . . 13--16
G. Booch and
M. Vilot Logical design: software component
libraries . . . . . . . . . . . . . . . 18, 20--22
C. Skelly In the land of OOP . . . . . . . . . . . 23--26
J. Soukup Beyond templates. 1. (C++) . . . . . . . 27--31
G. Horstmann The Microsoft C/C++ Version 7 compiler:
A first impression . . . . . . . . . . . 53--57
J. M. Coggins Questioning conventional `wisdom' about
C++ code size and execution speed . . . 58--61
N. M. Wilkinson Subtleties of C++ operator overloading 36--41
H. Strickland Object databases: a deep look at
transparency . . . . . . . . . . . . . . 42--46
T. Cargill A dynamic vector is harder than it looks 47--50
B. Leggett The USL C++ Standard Components release
2 (end user package) . . . . . . . . . . 69--73
S. Meyers Using C++ effectively. Approaches to
effectiveness . . . . . . . . . . . . . 34--39
S. Tavakkolian Crossing paradigms. A pilgrim's journey
from C to C++ . . . . . . . . . . . . . 40--45
R. Martin Abstract classes and pure virtual
functions . . . . . . . . . . . . . . . 46--52
M. Ball Inside templates: implementing C++
strategies . . . . . . . . . . . . . . . 36--40
P. Becker A msgstream class for smart formatting:
Easing the translator's job . . . . . . 42--48
D. Bartels and
J. Robie Persistent objects and object-oriented
databases for C++ . . . . . . . . . . . 49--50, 52--56
M. Carroll Invasive inheritance: modifying a base
class to enable inheritance . . . . . . 34--42
M. Banahan Cross-over training: making the
transition from C to C++ . . . . . . . . 44--48
D. Schmidt Systems programming with C++ wrappers:
encapsulating IPC services with
object-oriented interfaces . . . . . . . 50--54
S. Meyers Using C++ effectively. Examining
development tools . . . . . . . . . . . 30, 32--35
D. Reed Engineering the transition to C++: a
manager's perspective on realizing the
benefits of OOP . . . . . . . . . . . . 36, 38--42
D. Vines and
Z. Kishimoto Smalltalk's runtime type support for C++ 44--52
J. M. Coggins Practical principles for library design.
I. Selecting the right abstractions is
the key . . . . . . . . . . . . . . . . 38--42
D. C. Schmidt Encapsulating operating system IPCs. An
object-oriented interface for
event-driven UNIX I/O multiplexing . . . 43--50
P. Becker Iterators, portability, and reuse . . . 51--54
W. Atwood and
A. Breakstone and
D. Britton and
T. Burnett and
D. Myers and
G. Word The GISMO project (C++) . . . . . . . . 38--43
M. Sakkinen How should virtual bases be initialized
(and finalized)? . . . . . . . . . . . . 44--50
S. C. Dewhurst Subobject members . . . . . . . . . . . 51--53
J. Webster and
F. Douglas C++ is everywhere . . . . . . . . . . . 36--39
R. J. Reid C++ as a first programming language . . 41--44
S. Teale Transplanting a tree-recursive LISP
algorithm to C++ . . . . . . . . . . . . 45--48
B. Stroustrup Library design using C++ . . . . . . . . 14--22
D. Lea The GNU C++ library . . . . . . . . . . 24--27
T. Keffer The design and architecture of Tools.h++ 28--33
M. Carroll Design of the USL Standard Components 34--39, 53
G. Booch and
M. Vilot Simplifying the Booch Components . . . . 41--52
T. L. Hansen Enhancing memory allocation. An array
reallocation/renew function for C++ . . 20--22, 24, 26--30
S. Vinoski Distributed object computing with CORBA 32--38
N. C. Myers Memory management in C++. I. Fine-tuning
your programs . . . . . . . . . . . . . 39--41, 43
J. J. Barton and
L. R. Nackman Scientific and engineering programming
in C++: grafting onto our roots . . . . 26--31
D. C. Schmidt A C++ wrapper for UNIX I/O multiplexing:
the object-oriented design and
implementation of the Reactor . . . . . 32--43
B. P. Stroustrup Why consider language extensions?
Maintaining a delicate balance . . . . . 44--51
M. Stal and
U. Steinmuller Generic dynamic arrays: integrating
dynamic arrays into C++ templates . . . 30--35, 38
D. R. Reed Exceptions: pragmatic issues with a new
language feature . . . . . . . . . . . . 39--44
H. Strickland ODMG-93: the object database standard
for C++ . . . . . . . . . . . . . . . . 45--48
W. F. Tichy and
J. Heilig and
F. Newbery Paulisch A generative and generic approach to
persistence . . . . . . . . . . . . . . 22--33
S. Churchill Exception recovery with smart pointers 34--35, 38--42
E. Arjomandi and
W. O'Farrell and
I. Kalas Concurrency support for C++: an overview 44--50
R. Martin A practical example of object-oriented
analysis and design . . . . . . . . . . 18--23
I. Silva-Lepe and
W. Hursch and
G. Sullivan A report on Demeter C++ . . . . . . . . 24--30
C. L. Havener A C++ application story . . . . . . . . 31--33
J. Lajoie Exception handling: supporting the
runtime mechanism . . . . . . . . . . . 36--39, 42--43
R. van Loon Introducing the X Window System . . . . 45--47
D. Schmidt A domain analysis of network daemon
design dimensions . . . . . . . . . . . 50--59
C. S. Horstmann Extending the iostream library . . . . . 22--29
M. Moudgill Reverse-engineering manipulators . . . . 30--33
M. Stal and
U. Steinmuller Implementing a text editor using dynamic
arrays . . . . . . . . . . . . . . . . . 34--39, 46
J. Lajoie Exception handling: supporting
first-class objects . . . . . . . . . . 35--39
J. O. Coplien Generative pattern languages: an
emerging direction of software design 18--22, 66--67
J. Robie Event handling in object-oriented
databases . . . . . . . . . . . . . . . 24--27
D. C. Schmidt A case study of C++ design evolution . . 28--36
S. Vinoski Mapping CORBA IDL into C++ . . . . . . . 20--23, 55
J. Crawford Runtime parameterization. 1 . . . . . . 24--29
M. J. Vilot An introduction to the Standard Template
Library . . . . . . . . . . . . . . . . 22--29, 35
B. Stroustrup Making a vector fit for a standard . . . 30--34
S. R. Davis Armor cladding C++ classes . . . . . . . 36--39, 41
M. Speh and
C. Dinnell C++ and the World Wide Web . . . . . . . 18--23
G. Flanagin and
N. Rimmer Doing it (C++ software reuse project) 24--28
M. Carroll and
M. Ellis Tradeoffs of interface classes . . . . . 29--32
J. J. Barton and
L. R. Nackman Dimensional analysis . . . . . . . . . . 39--40, 42--43
C. S. Horstmann OO design tools with C++ code generation 56--58, 60--64
M. J. Vilot The C++ standard library . . . . . . . . 28--34
D. Remba A survey of the computer generated
imagery landscape . . . . . . . . . . . 36--41
R. Hickey Callbacks in C++ using template functors 42--50
T. Kontogiorgos and
M. Kim A C++ template-based application
architecture . . . . . . . . . . . . . . 51--56, 58
S. Vinoski and
D. Schmidt DOC by example: modelling distributed
object applications . . . . . . . . . . 64--68
M. Ellis and
M. Carroll Tradeoffs of exceptions . . . . . . . . 12, 14, 16
S. Meyers Bounding object instantiations. I . . . 18--22
D. Jordan Identifying ODMG objects . . . . . . . . 24, 26--27
D. Box Building C++ components using OLE2 . . . 28--34
J. Vlissides Pattern hatching-perspectives from the
``gang of four'' . . . . . . . . . . . . 36--39
J. Lajoie Standards update: type conversions . . . 40--46
D. C. Schmidt and
P. Stephenson Using design patterns to evolve system
software from UNIX to Windows NT . . . . 47--60
J. J. Barton and
L. R. Nackman Algebra for C++ operators . . . . . . . 70--74
E. B. Flanagan Risky business (software development
management) . . . . . . . . . . . . . . 75--76, 78
Don Box 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 . . . . 15--19
B. Berg and
E. Rowlance An object-oriented framework for I/O . . 28--35
T. Veldhuizen Using C++ template metaprograms . . . . 36--38, 40, 42--43
S. Trinoski and
D. Schmidt Comparing alternative distributed
programming techniques . . . . . . . . . 44--53
T. Veldhuizen Expression templates . . . . . . . . . . 26--31
N. Myers A new and useful technique: ``traits'' 32--35
J. H. Peden Operator ()() for array of array (of
array) class access . . . . . . . . . . 36--38, 40--41
J. Lajoie Function overload resolution: selection
of the best viable function . . . . . . 12--17, 56
G. Glass STL in action. Helper algorithms . . . . 18--21
H. M. Muller Ten rules for handling exception
handling successfully . . . . . . . . . 22--36
R. C. Martin The open-closed principle [software
maintenance] . . . . . . . . . . . . . . 37--43
D. C. Schmidt Connector. A design pattern for actively
initializing network services . . . . . 46--50, 52--56
F. Onion Object persistence in MFC . . . . . . . 57--60
C. S. Horstmann C++ class libraries for numerical
programming . . . . . . . . . . . . . . 61--64, 66
J. O. Coplien The human side of patterns . . . . . . . 73--74, 76--78, 80
J. Vlissides Protection. I. The Hollywood principle 14, 16--19
S. Leary C++ exception handling in multithreaded
programs . . . . . . . . . . . . . . . . 20--31
M. L. Kamahele ShMem --- a C++ class library for
managing objects in shared memory . . . 32--39, 60
J. Fitzpatrick A case study: converting C programs to
C++ . . . . . . . . . . . . . . . . . . 40--45, 63
T. Cargill An overview of Java for C++ programmers 46--49
D. C. Schmidt and
S. Vinoski Comparing alternative programming
techniques for multithreaded servers . . 50--59
J. J. Barton and
L. R. Nackman Automatic differentiation . . . . . . . 61--63
D. Jordan OQL: the Object Query Language . . . . . 64--66, 71--73
K. Jameson Multiplatform productivity lessons . . . CPS4--CPS6, CPS9
M. Jeghers GUI development with cross platform
toolkits . . . . . . . . . . . . . . . . CPS7--CPS9
R. C. Martin The Liskov substitution principle . . . 14, 16--17, 20--23
J. W. Reeves Coping with exceptions . . . . . . . . . 24--35
D. Forguson Programming with the MFC document
template architecture . . . . . . . . . 36--41
J. Hamilton Reusing binary objects with DirectToSOM
C++ . . . . . . . . . . . . . . . . . . 42--51
D. Box Com smart pointers also considered
harmful . . . . . . . . . . . . . . . . 54--57
F. Onion and
A. Harrison Dynamic data structure serialization in
MFC . . . . . . . . . . . . . . . . . . 58--62
C. S. Horstmann Java programming with Sun's Java
development kit . . . . . . . . . . . . 63--70
J. Vlissides Protection: membership has its
privileges . . . . . . . . . . . . . . . 11--13, 16--18, 28
S. Meyers Smart pointers. I . . . . . . . . . . . 19--23
R. Van Loon The power of multimedia. Strengthen your
applications to power multimedia
features . . . . . . . . . . . . . . . . 24--28
S. Cohen Dynamic inheritance in C++ . . . . . . . 30--37
M. Van Rooyen Alternative C++. New methods for solving
old problems . . . . . . . . . . . . . . 38--42
D. Forguson Extending the MFC document template
architecture . . . . . . . . . . . . . . 43--53
D. C. Schmidt and
S. Vinoski Comparing alternative programming
techniques for multithreaded CORBA
servers . . . . . . . . . . . . . . . . 56--66
J. J. Barton and
L. R. Nackman Hello ANSI/ISO . . . . . . . . . . . . . 68--70, 72--73
G. Glass A universal streaming service . . . . . 74--76, 81--83
S. Cohen Lightweight persistence in C++ . . . . . 22--32
C. Moth Lightweight classes . . . . . . . . . . 33--39
T. Linenbach Implementing reusable binary association
in C++ . . . . . . . . . . . . . . . . . 40--47, 51
F. Onion and
A. Harrison Dialog data exchange in MFC . . . . . . 48--51
J. Reeves Exceptions and Standard C++ . . . . . . 56--59, 62--64
A. Koenig Inheritance, assignment, and slicing . . 71--72
J. Lajoie The memory model-type representations 73--76, 81--83
J. Vlissides To kill a singleton . . . . . . . . . . 10, 12, 16--19
S. Meyers Smart pointers, nullness, and type
conversions . . . . . . . . . . . . . . 20--23
J. Lakos Large-scale C++ software design. 1.
Mentor Graphics experiences using C++
for large systems . . . . . . . . . . . 26--37
S. Lippman The varieties of object . . . . . . . . 38--50
T. R. Mueller Overcoming the problems in a large scale
C++ project. AT&T's gamble with C++ as a
primary programming language . . . . . . 51--52
J. Fitzpatrick Redesigning a graphics test program
using C++ . . . . . . . . . . . . . . . 54--60
R. C. Martin The Dependency Inversion Principle . . . 61--66
D. Forguson Developing the view component in MFC . . 67--74, 76
J. J. Barton and
L. R. Nackman While (converting to C++) use iterators 77--78, 83, 87
S. Henkel and
W. Dangelmaier Evaluating class libraries for
interprocess communication . . . . . . . 21--29
K. Kreft and
A. Langer Iterators in the Standard Template
Library . . . . . . . . . . . . . . . . 31--37
T. H. Harrison and
D. C. Schmidt Evaluating the performance of OO network
programming toolkits . . . . . . . . . . 39--46
D. C. Schmidt and
S. Vinoski Comparing alternative programming
techniques for multithreaded CORBA
servers . . . . . . . . . . . . . . . . 47--56
F. Onion and
A. Harrison Chain of Responsibility and command
targets . . . . . . . . . . . . . . . . 57--59, 62--63
J. W. Reeves Ten guidelines for exception
specification . . . . . . . . . . . . . 64--68, 70, 88
H. Alicea and
G. Glass Using the universal streaming service
with CORBA . . . . . . . . . . . . . . . 12--19
J. Vissides The trouble with Observer . . . . . . . 20--24
S. Meyers Smart pointers: automating inheritance
and const conversions . . . . . . . . . 25--27
R. G. White Advantages and disadvantages of unique
representation patterns . . . . . . . . 28--35
P. Gautier Visitors revisited . . . . . . . . . . . 36--39, 42--45
D. Bulka Performance and C++: separating myth
from reality . . . . . . . . . . . . . . 46--54
J. Lakos Large-scale C++ software design:
physical hierarchy. 2. Effective
testing, improved maintainability,
independent reuse . . . . . . . . . . . 55--64
A. Koenig Copying and insertion in STL algorithms 65--66
J. Lajoie The C++ memory model. Pointer
manipulations . . . . . . . . . . . . . 67--72
J. O. Coplien Code patterns . . . . . . . . . . . . . 18--25
J. Lajoie The C++ memory model: new and delete
operators . . . . . . . . . . . . . . . 26--33, 44
J. Lajoie The C++ Standards Committee's sixth
year-organization and schedule update 30--31
J. Soukup Quality patterns . . . . . . . . . . . . 34--44
J. Soukup Another controversy: managing groups of
cooperating classes . . . . . . . . . . 46--47
S. Vinoski and
D. C. Schmidt Distributed callbacks and decoupled
communication in CORBA . . . . . . . . . 48--56, 77
D. Forguson Extending the MFC document template
architecture . . . . . . . . . . . . . . 57--65
J. J. Barton and
L. R. Nackman Scientific and engineering C++-is this
standard input? . . . . . . . . . . . . 66, 68--69
J. Vlissides Generation Gap [software design pattern] 12, 14--18
S. Meyers Refinements to smart pointers . . . . . 19--22
A. Koenig Containers and pointer comparisons . . . 23--26
K. Kreft and
A. Langer Iterators in the Standard C++ Library 27--30, 32
M. P. Lindner Designing for safe hashing. Implementing
efficient dynamic search structures . . 36--41
J. Lakos Large-scale C++ software design:
levelization, insulation, and packages.
3. Avoiding excessive compile- and
link-time dependencies . . . . . . . . . 42--56
R. C. Martin Granularity [object-oriented design] . . 57--62
J. W. Reeves Exceptions and debugging [in C++] . . . 63--71
J. O. Coplien Pattern languages . . . . . . . . . . . 15--21
F. Onion and
A. Harrison Framework class factories . . . . . . . 22--24
M. Hansen How to reduce code bloat from STL
containers . . . . . . . . . . . . . . . 34--41
R. C. Martin Java and C++: a critical comparison . . 42--49
P. Jain and
D. C. Schmidt Experiences converting a C++
communication software framework to Java 50--66
G. Glass The Java Generic Library . . . . . . . . 70--74
R. L. Stewart and
J. Storey and
D. Huang Decentralized event handling . . . . . . 12--19
K. Kreft and
A. Langer Building an iterator for STL and the
Standard C++ Library . . . . . . . . . . 20--27
J. Hamilton Using Distributed SOM with DirectToSOM
C++ . . . . . . . . . . . . . . . . . . 28--36
D. C. Schmidt and
S. Vinoski The OMG Events Service . . . . . . . . . 37--46
J. Vlissides Type laundering . . . . . . . . . . . . 47--52
R. C. Martin Large-scale stability . . . . . . . . . 54--60
J. J. Barton and
L. R. Nackman Generating and transforming . . . . . . 62--64
R. C. Martin and
J. W. Newkirk and
B. Rao Taskmaster: an architecture pattern for
GUI applications . . . . . . . . . . . . 12--14, 16--23
P. Thompson and
G. Bumgardner Threads.h++: a portable C++ library for
multithreaded programming . . . . . . . 24--37
P. Jakubik Patterns in practice: abstract client 38--44
A. Langer and
K. Kreft Combining object-oriented design and
generic programming . . . . . . . . . . 45--49, 69
F. Onion Multithreading in MFC . . . . . . . . . 50--53, 56
J. W. Reeves Reflections on exceptions . . . . . . . 57--65
M. Davis Well-mannered objects: tips on porting
C++ to Java . . . . . . . . . . . . . . 14--21
G. Cochran and
R. Weisz Developing reusable code in the real
world: process and techniques . . . . . 22--31
J. Sime Guarded pointers: moving smart pointers
into multithreaded systems . . . . . . . 32--41
R. C. Martin Design patterns for dealing with dual
inheritance hierarchies in C++ . . . . . 42--48
J. Soukup Implementing patterns . . . . . . . . . 49--50
Jim Shur 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 18--29, 68