Code Complete: A Practical Handbook of Software Construction, Second Edition

Index

[SYMBOL] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W]

C language

     ADTs with

     boolean expression syntax

     description of

     naming conventions for 2nd

     pointers

     string data types 2nd

     string index errors C#

C++     assertion example     boolean expression syntax

     debugging stubs with

     description of

     DoNothing() macros     exceptions in

     inline routines     interface considerations     layout recommended     macro routines

     naming conventions for

     null statements

     parameters, by reference vs. by value

     pointers 2nd 3rd     preprocessors, excluding debug code     resources for     side effects

     source files, layout in caching, code tuning with Capability Maturity Model (CMM)

capturing design work

Cardinal Rule of Software Evolution

CASE (computer-aided software engineering) tools

case statements    alpha ordering [See conditional statements, case statements; conditional statements, switch statements; control structures, case]

     checklist

     debugging     default clauses

     drop-throughs

     end of case statements     endline layout

     error detection in     frequency of execution ordering 2nd

     if statements, comparing performance with

     key points

     language support for

     nested ifs, converting from 2nd

     normal case first rule

     numeric ordering

     ordering cases

     parallel modifications to

     phony variables

     polymorphism preferable to

     redesigning

     refactoring 2nd

     simple action guideline     table-driven methods using

change control character arrays [See also string data types]character data types

    arrays vs. string pointers, 299 C language [See data types, characters]

     character sets

     checklist     conversion strategies

     magic (literal) characters     Unicode 2ndcharacter, personal     analysis skills

     communication skills

     compiler messages, treatment of

     computer-science graduates

     cooperation skills     creativity 2nd     curiosity     development process awareness

     discipline     estimations     experience

     experimentation

     gonzo programming

     habits

     humility 2nd 3rd     importance of

     intellectual honesty

     intelligence     judgment

     key points

     laziness     mistakes, admitting to

     persistence     practices compensating for weakness

     problem solving

     professional development

     reading

     religion in programming, harmful effects of

     resources on

     status reporting

     successful projects, learning from

checklists

     abstraction

     architecture

     arrays

     backups

     boolean expressions     case statements

     character data types     classes 2nd 3rd 4th 5th     code tuning 2nd

     coding practices

     comments 2nd

     conditional statements     configuration management

     constants     construction practices     control structures 2nd 3rd     daily build and smoke tests

     data organization

     data types

     debugging

     defects 2nd     defensive programming     design 2nd     documentation 2nd

     encapsulation     enumerated types     fixing defects

     formal inspections 2nd

     formatting

     goto statements

     if statements     inheritance

     initialization

     integration     interfaces

     layout

     loops     names 2nd

     pair programming     parameters

     performance tuning

     pointers

     prerequisites

     programming tools

     pseudocoding

     quality assurance 2nd 3rd

     refactoring 2nd 3rd

     requirements 2nd

     routines 2nd 3rd

     speed, tuning for

     statements

     straight-line code

     strings     structures

     table-driven methods     testing 2nd     tools

     type creation

     variables 2nd 3rd

circular dependencies class-hierarchy generators

classes    abstract objects, modeling [See object-oriented programming, objects]     abstraction checklist     alternates to PPP

     architecture prerequisites

     assumptions about users

     bidirectional associations

     calls to, refactoring     case statements vs. inheritance     centralizing control with     changes, limiting effects of

     checklists 2nd 3rd     coding routines from pseudocode     cohesion as refactoring indicator

     complexity issues

     constant values returned

     constructors

     containment     coupling considerations 2nd

     data-free

     deep inheritance trees     defined

     delegation vs. inheritance, refactoring

     descendants, refactoring indicator for     designing 2nd 3rd 4th

     disallowing functions and operators     documenting 2nd

     encapsulation 2nd

     extension, refactoring with

     factoring, benefit of

     files containing

     foreign routines, refactoring with

     formalizing contracts for interfaces

     formatting

     friend, encapsulation violation concern

     global data, hiding

     god classes

     hacking approach to

     hiding implementation details

     implementation checklist     indirect calls to other classes

     information hiding     inheritance 2nd     initializing members

     integration 2nd 3rd

     irrelevant classes

     is a relationships     key points for 2nd

     language-specific issues     layout of     limiting collaboration     Liskov Substitution Principle

     member variables, naming 2nd

     minimizing accessibility rule

     mixins

     modeling real-world objects     multiple per file, layout of     naming 2nd     number of members

     number of routines     object names, differentiating from     objects, contrasted with

     overformatting

     overriding routines 2nd

     packages

     parallel modifications refactoring indicator     planning for program families

     private vs. protected data

     private, declaring members as     protected data

     pseudocode for designing

     public members 2nd 3rd     read-time convenience rule

     reasons for creating     refactoring 2nd 3rd 4th

     resources

     reusability benefit of

     review and test step

     routine construction step

     routines, unused 2nd

     semantic violations of encapsulation

     Set() routines, unnecessary

     similar sub and superclasses

     single-instance

     singleton property, enforcing

     steps in creating

     streamlining parameter passing

     subclasses 2nd     superclasses for common code

     test-first development     testing with stub objects     unidirectional associations

     visibility of

     warning signs for 2nd

cleanroom development cleanup steps, PPP

CMM (Capability Maturity Model) Cobol code coverage testing code libraries 2nd

code quality analysis tools

code reading method

code tuning

    80/20 rule [See performance tuning, code tuning for]     advantages from     algebraic identities     appeal of

     arrays 2nd 3rd     assembler, listing tools     assembler, recoding to

     bottleneck identification

     caching data

     checklists 2nd

     comparing logic structures     competing objectives dilemma

     compiler considerations 2nd

     converting data types     correctness, importance of

     data transformations

     data type choices     database indexing

     defects in code     defined

     DES example

     design view

     disadvantages of

     disassemblers

     execution profiler tools

     expressions

     feature specific

     frequency, testing in order of

     frequently used code spots

     hardware considerations

     improvements possible

     indexing data

     inefficiency, sources of     initializing at compile time

     inline routines     input/output     integers preferred to floating

     interpreted vs. compiled languages 2nd

     iteration of 2nd

     jamming loops     key points 2nd

     language specificity     lazy evaluation     lines of code, minimizing number of     logic manipulation guidelines

     lookup tables for 2nd

     loops

     low-level language, recoding to

     measurement to locate hot spots 2nd     memory vs. file operations     minimizing work inside loops     multiplication, changing to addition

     nested loop order     old wives' tales     operating system considerations

     operation speeds, presumptions about

     operations, costs of common

     optimizing as you go

     overview of     paging operations

     Pareto Principle

     precomputing results     program requirements view of

     refactoring, compared to

     resource goals     resources on 2nd

     right shifting     routines 2nd

     sentinel tests for loops

     short-circuit evaluation

     speed, importance of

     strength reduction 2nd

     subexpression elimination

     summary of approach for

     system calls 2nd

     tools

     unrolling loops

     unswitching loops

     variations in environments for

     when to tune

code-generation wizards coding 2nd

     practices checklist     software construction ascohesion

     interfaces, class

     routines, designing with

     strength reduction 2nd coincidental cohesion

collaboration    code reading [See construction, collaborative; quality of software, collaborative construction]     collective ownership benefits     comparisons of techniques, table of

     cost advantage

     defined 2nd

     design phase

     development time benefit     dog-and-pony shows     extending beyond construction     Extreme Programming method

     General Principle of Software Quality     key points     mentoring aspect of

     purpose of

     standards, IEEE

     testing, compared to

     walk-throughs collections, refactoring

collective ownership [See also collaboration]

comments    /* vs. // [See documentation, comments]

     abbreviations in

     algorithms     argument against

     authorship     bad code, on

     blank lines around

     Book Paradigm for

     categories of

     checklists 2nd

     classes

     coded meanings

     control structures 2nd

     declarations with 2nd 3rd

     descriptions of code intent

     distance to code guideline

     efficient creation of

     endline comments

     errors, marking workarounds     explanatory

     files     flags, bit level     global variables 2nd

     indentation guidelines

     individual lines with

     input data 2nd     integrating into development

     interfaces, class     interfaces, routine     Javadoc 2nd     key points

     layout guidelines

     legal notices

     length of descriptions

     level of code intent     loops     maintenance of 2nd 3rd     major vs. minor

     markers     non-code essential information     numerical data

     optimum density of

     output data

     paragraphs of code with 2nd

     parameter declarations     parts of programs

     performance considerations

     preceding code rule     proportionality of

     pseudocode, deriving from 2nd 3rd

     purpose of     repeating code with

     resources on     routines with 2nd

     self-commenting code

     Socratic dialog about

     standards, IEEE

     style differences, managing

     style violations

     summaries of code

     surprises

     tricky code 2nd

     undocumented features

     variables

     version control

     why vs. how

     workarounds commitment delay strategy

communication skills, importance of communicational cohesion communications, development team

comparisons

     floating-point equality

     mixed data typescompilers

    binding during compilation [See executable-code tools, compilers]     broken builds     data type warnings     debugging tools, as 2nd

     errors, finding in routines

     line numbers, debugging with

     messages, treatment of 2nd

     multiple error messages     optimizations by     performance tuning considerations     project-wide standards for

     speeds from optimization, table of     tools for     tricky code optimization

     validators with

     warnings 2nd

completeness of requirements checklist

complex data typescomplexity

     abstraction for handling

     classes for reducing     coding conventions for reducing

     control structure contributions to

     conventions for managing     decision points, counting

     importance of     isolation, classes for

     live time

     management 2nd

     McCabe's metric

     mental objects held, measure of

     methods for handling

     minimization goal

     patterns, reducing with

     problem domain, working at

     reliability correlated with

     routines for reducing

     size of projects, effect on

     span

component testing components, buying 2nd

Composite pattern compound boundaries compound statements

computed-value qualifiers of variable names

computer-aided software engineering (CASE) tools

conditional statements    boolean function calls with [See control structures, conditional flow]

     boolean variables recommended     chained if-then-else statements     checklist     common cases first guideline

     comparing performance of

     covering all cases

     defined

     eliminating testing redundancy     else clauses     equality, branching on     error processing examples

     frequency, testing in order of     key points     lookup tables, substituting

     normal case first guideline

     normal path first guideline

     null if clauses

     plain if-then statements     refactoring

     short-circuit evaluation

confessional debuggingconfiguration management

    architectural anticipation of change [See managing construction, change control; managing construction, configuration management]

     backup plans 2nd     boards, change-control

     bureaucratic considerations     checklist

     code changes

     cost, estimating

     defined

     design changes

     estimating change costs

     grouping change requests

     high change volumes

     identifying areas of change

     machine configurations, reproducing

     purpose of

     requirements changes 2nd 3rd

     resources on

     SCM     tool version control

     version-control software const keyword, C++ 2nd 3rd 4th 5thconstants

     checklist

     consistency rule

     declarations using     defined

     emulation by global variables     initializing     literals, avoiding with     naming 2nd 3rd

     purpose of

     refactoring

     simulating in languages lacking

construction     guidelines     percent of total activity, by size of project     resources on

construction decisions    checklist of major construction practices [See construction, decisions]     coding practices checklist

     early-wave environments

     key points for

     major construction practices, selecting

     mature technology environments     programming conventions

     programming into languages

     quality assurance checklist     teamwork checklist

     technology waves, determining your location in

     tools checklistconstruction schedules, estimating

    approaches to, list of [See construction, schedules, estimating]     catching up from behind

     controlling vs. estimating

     factors influencing

     level of detail for

     multiple techniques with comparisons

     objectives, establishing

     optimism

     overview

     planning estimation time

     reduction of scope

     reestimating

     requirements specification

     resources for

     teams, expandingconstructors

     deep vs. shallow copies     exceptions with     guidelines for

     initializing data members

     refactoring

     singleton property, enforcing container classes

containment 2nd continuation lines continue statements 2nd 3rd continuous integration

control structures

     checklists 2nd 3rd

     commenting 2nd

     complexity, contributions to     compound statements     continuation lines in     data types, relationship to

     documentation     double indented begin-end pairs     iteration 2nd

     key points

     layout styles

     multiple returns from routines

     null statements     reliability correlated with complexity

     selective data with

     sequential data with     structured programming

     unindented begin-end pairs

     unusual, overview ofconventions, coding

    benefits of [See coding, conventions]     checklist

     hazards, avoiding with

     predictability benefit

converting data types

cooperation skills, importance of

correctness 2nd

costs

     change estimates

     collaboration benefits

     debugging, time consumed by

     defects contributing to

     detection of defects

     error-prone routines

     estimating 2nd     fixing of defects 2nd

     General Principle of Software Quality 2nd     pair programming vs. inspections     resources on

counted loops

coupling

     base classes to derived classes     classes, too tightly

     design considerations     flexibility of     goals of     loose 2nd

     object-parameter type

     semantic type

     simple-data-parameter type

     simple-object type     size of     visibility ofcoverage

     monitoring tools     structured basis testing CRC (Class, Responsibility, Collaboration) cards

creativity, importance of 2nd

cross-reference tools

curiosity, role in character

Currency data types customization, building metaphor for