Index
Note: Page numbers followed by b indicate boxes, f indicate figures and t indicate tables.
A
Abstract base classes (ABCs)
plugin implementation,
366
Abstraction
Access control
and getter/setter routines,
30
Access levels
encapsulation, language variations,
27
and logical hiding,
26–27
Active Server Pages (ASP), web development,
Actors, use case template elements,
115
Acumen Threadspotter, multithreading analysis,
240
Adaptable systems, architecture classifications,
129
Adapter pattern
Advanced API versions, parallel products,
248
Aggregation, UML class diagram,
23
Agile development, definition,
117–118
AIX, memory-based analysis,
239
Algorithms
and API usage,
behavioral patterns,
65–66
functionality compatibility,
252
functionality mismatch,
11
parallel development example,
Allocators
plugin implementation,
366
AMD CodeAnalyst, for performance analysis,
238
Android platform, API versions,
373t
Anonymous namespace, and external linkage,
205
ANSI C API
Apache Portable Runtime,
15t
API (Application Programming Interface) basics
contractor analogy,
1–2,
3f
encapsulation, language variations,
27b
and network protocols,
16–17
parallel development,
9–10
API design
API development stages,
106f
architecture design
OpenSceneGraph example,
125f
basic considerations,
class design
Liskov Substitution Principle,
135–139
documentation usability,
281
free operator overloading,
192
functional requirements
function design
technical debt
use cases
API design patterns
abstract base classes, overview,
86–87
Factory Methods
extensible example,
88–91
Observer pattern
Pimpl idiom
opaque pointers in C,
75–76
Singleton
vs. dependency injection,
81–82
implementation in C++,
77–79
API performance
and array references,
235
and functional compatibility,
252
#include minimization
input arguments via const reference,
210–212
and member variable hiding,
31
nonfunctional requirements,
112
API qualities (C++-specific)
const correctness
constructors and assignment
compiler-generated functions,
176–177
function parameters
pointer
vs. reference parameters,
198–199
operator overloading
operator addition to class,
193–195
templates
explicit instantiation API design,
187–190
API qualities (general)
coupling
class coupling reduction,
54–56
ease-of-use
misuse considerations,
40–42
platform independence,
51–52
resource allocation,
47–50
implementation detail hiding
minimal completeness
problem domain model
API reviews
API styles
ANSI C
data-driven APIs
object-oriented C++ APIs
template-based APIs
Application Binary Interface (ABI)
backward compatibility,
257
Architecture Description Languages, architecture design communication,
130
Architecture design
OpenSceneGraph example,
125f
Second Life Viewer,
14,
14f
Arrays
and initialization lists,
220
reference parameters,
198
references and iterators,
235
variant argument lists,
168
Array subscript
Assertions
contract programming,
315
implicit instantiation design,
186
Assignment operator
compiler-generated functions,
177
C++-specific APIs
compiler-generated functions,
176–177
initialization lists,
220
Association, UML class diagram,
23
at() method, and random access,
234
AutoDuck, documentation generation,
275
Automated documentation, creation,
274–276
Automated GUI testing, overview,
294
Automated Teller Machine (ATM)
Automated testing
API design,
continuous build systems,
326,
327f
B
Backward compatibility
API design,
API reviews
definition and types,
251
maintenance
removing functionality,
261
Basic API versions, parallel products,
248
Basic block coverage, testing tools,
323
Basic course
ATM use case example,
116
use case template elements,
115
Behavioral design patterns, examples,
65–66
Behaviors
defining with documentation,
268–269
Best practices
plugin implementation,
366
“The Big Three” rule,
176
Binary compatibility
in object-oriented C++ APIs,
159
Binary instrumentation, time-based performance analysis,
236
Binary operators
Bit fields, memory optimization,
222,
225
Black box testing
integration testing as,
297
Booleans
Boost library
implicit instantiation API design,
187
Boost Python
cross-language polymorphism,
345–346
scripting and language barrier,
333
Boost Test, overview,
320
Boundary conditions, definition,
302
Breadcrumbs, documentation usability,
280
Buffer overruns, definition,
303
Bug tracking
Bullseye Coverage, testing tools,
323
Business logic, data-driven APIs,
166
Business requirements, definition,
111
C
Caching
code robustness,
and getter/setter routines,
29
Callbacks
and architecture design,
130
and Factory methods,
88–89
Callgrind, for performance analysis,
238
Calling convention, adapter pattern,
96
Case studies
Cast operators, variant argument lists,
168
CcDoc, documentation generation,
275
Chaining
Change control process, API design,
Change request process, API design,
Circular dependency, architecture design,
129f
plugin system design,
364
C++ language basics
plugin implementation,
366
Class concept
documentation basics,
272
in object-oriented C++ APIs,
158
Class design
Liskov Substitution Principle,
135–139
Class diagrams
implementation hiding,
33–34
Class hierarchy
Class invariant, contract programming,
270
Client applications, and API performance,
226
Client/server protocol, and APIs,
16
C linkage
plugin implementation,
366
Cocoa (Apple)
Code bloat, and API performance,
226
Code coverage
Code duplication, and API code robustness,
Code examples
C++ usage
compiler-generated functions,
176–177
explicit instantiation,
188
implicit instantiation,
186
design
Liskov substitution principle,
135–136
design patterns
extensible factory methods,
89
Pimpl and smart pointers,
72–73
simple factory methods,
87
singleton
vs. dependency injection,
81–82
singleton
vs. monostate,
83
thread-safe singletons,
79
documentation
documentation usability,
280,
281
Doxygen documentation
extensibility
adding functionality,
374
policy-based templates,
386
general
“Hello World”,
“Hello World” with Qt,
13
parallel development,
STL for vector iteration,
12
TIFF dimensions with libtiff,
12
triangle render with OpenGL,
13
performance
constant declarations,
217
forward declarations,
213
initialization lists,
219
quality basics
class coupling reduction,
54–55
difficult to misuse APIs,
40
intentional redundancy,
56
platform independence,
51
robust resource allocation,
48–49
scripting
scripting with Boost Python
cross-language polymorphism,
345
scripting via Ruby with SWIG,
357–359
cross-language polymorphism,
356–357
styles
templates
vs. macros,
162
testing
contract programming,
315
playback functionality,
317
versioning
binary compatibility,
253
forward compatibility,
255
source compatibility,
252
version API creation,
244
versioning and backward compatibility
deprecating functionality,
260
CodeProphet Profiler, for performance analysis,
238
Code reuse
Code robustness, and API usage,
6–7
Coding conventions, C++-specific APIs,
207–208
Coding standards, as test quality,
302
Commenting
Doxygen
Common Lisp, and SWIG,
334
Common Object Request Broker Architecture (CORBA), features,
336–337
Communication
Community catalyst, plugin-based extensibility,
362
Compatibility levels
Compile errors
Compiler-generated functions, C++-specific APIs,
176–177
Compile-time speed
and explicit instantiation,
184
and redundant #include guards,
215t
Completion, API life cycle,
249f,
250
Component Object Model (COM), features,
335–336
Composition
Concurrency
architecture constraints,
123
nonfunctional requirements,
112
singleton thread safety,
80
Condition coverage
Condition testing, definition,
302
Configuration file
factory method example,
88
member variable hiding,
29
and parallel development,
Consistency
automated API documentation,
274
and backward compatibility,
261
documentation “look and feel”,
280
random access functionality,
234–235
Constants (general)
documentation basics,
272
Const correctness
Const references
and assignment operators,
175
forward declarations,
214
return value const correctness,
182–183
Constructors
behavior documentation,
268
Boost Python bindings,
339,
341
compiler-generated functions,
176–177
implementation method hiding,
32
input argument passes,
211
singleton
vs. dependency injection,
82
singleton
vs. monostate,
84
static initialization,
81
Container classes
forward compatibility,
256
language compatibility,
332
robust code,
variant argument lists,
168
Continuous build systems
Contractor analogy, API definition,
1–2,
3f
Contract programming
Convenience APIs
Conversion operators
and explicit keyword,
180
Copy constructor
input argument passes,
211
Copyleft license, definition,
278
Copy-on-write techniques
Copy semantics, Pimpl idiom,
71–72,
73
Core API
plugin API communication,
367
Counter monitoring, time-based performance analysis,
236
Coupling
API qualities
class coupling reduction,
54–56
and operator overloading,
192
Coverity, for performance analysis,
239
CppDoc, documentation generation,
275
CppUnit
Creational design patterns, examples,
65–66
Cross-language polymorphism
Cross-Platform Component Object Model (XPCOM), COM automation,
336
C# language
formal design notations,
127
robust resource allocation,
47–48
Curiously Recurring Template Pattern (CRTP), for extending,
387–389
Cyclic dependency, architecture design,
129f
D
Data-driven APIs
Data formats, documentation usability,
281
Data types
Dates, as version numbers,
243
Debugging
and getter/setter routines,
29
Debug modes, proxy patterns,
93
Decision coverage, testing tools,
323
Declarations
automated API documentation,
274
and explicit keyword,
179
and external linkage,
205
implementation detail hiding,
25–26
singleton
vs. monostate,
83
templates
vs. macros,
162
template terminology,
184
Default arguments
binary compatibility,
254
Default constructor
compiler-generated functions,
176–177
initialization lists,
220
singleton implementations,
77
#define (general)
version API creation,
244
Definition
API and parallel branches,
248
explicit instantiation design,
187–188
forward declarations,
54,
213
Dependency injection,
vs. Singleton,
81–82
Dependency problems
#include minimization
Deprecation
overview documentation,
276
Description
ATM use case example,
116
use case template elements,
114
Destructors
compiler-generated functions,
176–177
input argument passes,
211
object-oriented API disadvantages,
159
and resource allocation,
49
singleton
vs. monostate,
84
Diagrams, as documentation type,
280
DirectX, 3D graphics APIs,
12
Discoverability
automated API documentation,
274
Distributed systems, architecture classifications,
129
Doc++, documentation generation,
275
Doc-O-Matic, documentation generation,
275
Documentation
Apache HTTP Server example,
279f
API design,
API problem domain model,
21–22
C++ API elements,
Doxygen
overview documentation,
276
Qt Reference Documentation,
275f
Documentation lead, prerelease API reviews,
263
Double Check Locking Pattern (DCLP), Singleton thread safety,
80
Doxygen
documentation generation,
275
HTML output example,
285f
interface documentation,
159
private code testing,
312
sample header with documentation,
287–289
DRD, multithreading analysis,
240
“Dry run” modes, proxy patterns,
93
DTrace, for performance analysis,
238
Dynamic libraries
binary compatibility,
253
C++ API elements,
plugin system design,
364,
365
E
Ease-of-use
misuse considerations,
40–42
platform independence,
51–52
resource allocation,
47–50
Eiffel language, contract programming,
316
Electric Cloud, definition,
326
Embedding
forward declarations,
214
private code testing,
312
Encapsulation
and class coupling,
54–55
implementation member hiding,
32
member variable hiding,
28–29
in object-oriented C++ APIs,
159
return value const correctness,
183
enum keyword (general)
and binary compatibility,
254
documentation basics,
272
Environmental factors, architecture design,
123
Equivalence classes, definition,
302
Error codes
contract programming,
316
internalization support,
318
Error handling
record/playback functionality,
317
Event domains, key objects,
126
Event ordering, definition,
60
Evolution strategy, definition,
108
Examples, as documentation type,
276–277
Exceptions
and binary compatibility,
255
documentation basics,
273
plugin implementation,
366
Expert users, scripting advantages,
331
Explicit instantiation
and backward compatibility,
258
explicit keyword
conversion operators,
198
Explicit specialization, definition,
185
Expressiveness, scripting advantages,
331
Extensibility
via inheritance
functionality modification,
375–376
via plugins
Netscape Plugin API,
363b
plugin implementation,
366
scripting advantages,
331
via templates
Extensions
ATM use case example,
116
use case template elements,
115
External linkage
private code testing,
313
External metadata, plugin system design,
365
F
Façade pattern
Facebook, and C++ APIs,
Factory Methods
extensible example,
88–91
Failure reproducibility, as test quality,
302
Fake Object, definition,
308
Fast Fourier Transform (FFT), API avoidance,
11
Feature tags, version API creation,
245
FIFA 10, version numbers,
243
File formats
software branching strategies,
248–249
Fixture setup, unit testing,
296
Flat C APIs
backward compatibility,
258
binary compatibility,
255
Flexibility
nonfunctional requirements,
112
FMOD API
Formatting, coding conventions,
208
Forward compatibility
Forward declaration
Foundation Class library (Microsoft), and MVC,
100
Fragility, technical debt,
107
Framework
Free, Libre, Open Source Software (FLOSS)
Free functions
plugin implementation,
366
Free and Open Software (FOSS), definition,
277
Free operators,
vs. member operators,
191–193
Free Software Foundation (FSF), FLOSS licenses,
278
Frequently Asked Questions (FAQs), as documentation type,
277
Friend function
private code testing,
311
Friends
and binary compatibility,
254
and operator additions,
194
private code testing,
311
Friendship, and encapsulation,
27
Functional compatibility
Functionality extension, via inheritance,
374–376
Functionality mismatch, API avoidance,
11
Function calls
constant declarations,
218
contract programming,
314
operators and syntax,
195t
playback functionality,
317
Function coverage
Function design
Function documentation,
272
Function parameters
pointer
vs. reference parameters,
198–199
Future proofing, plugin-based extensibility,
362
G
Gcov
Generalization
Generic Plugin Manager, plugin system design,
365
GenHelp, documentation generation,
275
Getter/setter methods
and class coupling,
54–55
constant declarations,
218
language compatibility,
332
member variable hiding,
28–29
singleton
vs. dependency injection,
82