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]

packages

paging operations

pair programming

    benefits of [See collaboration, pair programming]

     checklist

     coding standards support for

     compared to other collaboration

     defined     inexperienced pairs

     key points     pace, matching     personality conflicts

     resources

     rotating pairs

     team leaders     visibility of monitor

     watching     when not to useparameters of routines    abstraction and object parameters [See routines, parameters]

     actual, matching to formal

     asterisk (*) rule for pointers

     behavior dependence on

     by reference vs. by value     checklist for, 185 C-library order     commenting     const prefix 2nd 3rd

     dependencies, clarifying     documentation     enumerated types for

     error variables

     formal, matching to actual

     global variables for

     guidelines for use in routines     in keyword creation

     input-modify-output order

     Java     list size as refactoring indicator

     matching actual to formal

     naming 2nd 3rd 4th 5th 6th     number of, limiting

     objects, passing     order for

     out keyword creation

     passing, types of

     refactoring 2nd

     status

     structures as

     using all of rule

     variables, using as

     Visual Basic

parentheses

     balancing technique

     layout with

Pareto Principle

passing parameterspatterns

    advantages of [See design, patterns, common]     alternatives suggested by     communications benefit

     complexity reduction with

     disadvantages of

     error reduction benefit     Factory Method

     resource for     table of people first theme performance appraisals

performance tuning

     algorithm choice

     architecture prerequisites

     arrays 2nd     checklist     comments, effects on     competing objectives dilemma 2nd

     compiler considerations 2nd     correctness, importance of     database indexing

     defects in code

     DES example

     design view

     feature specific     hardware considerations

     inefficiency, sources of

     information hiding considerations of     input/output

     interpreted vs. compiled languages

     key points     lines of code, minimizing number of

     measurement of     memory vs. file operations

     old wives' tales

     operating system considerations

     operations, costs of common

     overview of

     paging operations

     premature optimization

     program requirements view of

     purpose of

     quality of code, impact on

     resource goals

     resources

     routine design 2nd 3rd

     speed, importance of     summary of approach for

     system calls     timing issues     user view of coding

     when to tune

periodicals on programming

Perl persistence of variables 2nd

personal character perturbers phased integration phonic abbreviations of names

PHP (PHP Hypertext Processor) 2nd

physical environment for programmers

planning

     analogy argument for     building metaphor for     data arguing for     good practices table for

     logical argument forpointers     & (pointer reference symbol)

     2nd 3rd [See data types, pointers]

     > (pointer symbol)

     address of 2nd

     allocation of 2nd 3rd     alternatives to

     as function return values

     asterisk (*) rule     auto_ptrs

     bounds checking tools

     C language     C++ examples 2nd

     C++ guidelines     checking before using 2nd

     checklist for

     comparisons with

     contents, interpretation of

     cover routines for

     dangers of 2nd

     data types pointed to

     deallocation of 2nd 3rd

     debugging aids

     declaring 2nd

     deleting 2nd

     diagramming

     dog tag fields

     explicit typing of     explicitly redundant fields

     extra variables for clarity     hiding operations with routines     initializing 2nd 3rd

     interpretation of address contents

     isolating operations of

     key points     languages not providing

     linked lists, deleting in     location in memory     memory corruption by     memory parachutes

     null, setting to after deleting

     null, using as warnings

     overwriting memory with junk

     parts of     passing by reference     references, C++     resources for

     SAFE_ routines for     simplifying complicated expressions     sizeof()

     smart

     string operations in C

     type casting, avoiding

     variables referenced by, checkingpolymorphism

    case statements, replacing with [See object-oriented programming, polymorphism]

     defined     language-specific rules

     nested ifs, converting to

polynomial expressionsportability

     data types, defining for     defined

     routines for

postconditions

     routine design with

     verification

PPP (Pseudocode Programming Process)

    algorithms, researching [See pseudocode, PPP]

     alternates to

     checking for errors

     checklist for

     cleanup steps

     coding below comments

     coding routines from

     data structure for routines     declarations from

     defined     designing routines     error handling considerations

     example for routines

     functionality from libraries

     header comments for routines     high-level comments from

     iterating     key points for     naming routines     performance considerations

     prerequisites

     problem definition

     refactoring

     removing errors     repeating steps     reviewing pseudocode     stepping through code

     testing the code 2nd     writing pseudocode step precedence, misleading

preconditions

     routine design with

     verification

prefixes, standardization of premature optimization

preparation

preprocessors     C++

     debugging aids, removing with

     purpose of     writing

prerequisites, upstream    analogy argument for [See construction, prerequisites]

     boss readiness test

     checklist for

     choosing between iterative and sequential approaches

     coding too early mistake

     compelling argument for

     data arguing for

     error detection, doing early

     goal of

     good practices table for

     importance of

     incomplete preparation, causes of

     iterative and sequential mixes

     iterative methods with 2nd     key points for

     kinds of projects     logical argument for     manager ignorance problem

     problem definition

     risk reduction goal

     skills required for success     time allowed for

     WIMP syndrome     WISCA syndrome Principle of Proximity 2nd private data

problem domain, programming at

problem-definition prerequisites

problem-solving skills development

procedural cohesion procedures     naming guidelines for     when to use

processes, developmentproductivity     effects of good construction practice

     industry average

     size of projects, effects on

professional development

professional organizationsprogram flow

     control of

     sequential program organization prerequisite

program size

programmers, character of programmers, treatment of

     overview     physical environment

     privacy of offices

     religious issues

     resources on

     style issues

     time allocations

     variations in performance

programming conventions

     choosing

     coding practices checklist

programming into languages 2nd

programming language choice

    Ada [See construction decisions, programming languages]

     assembly language     Basic

     C     C#     C++

     Cobol

     expressiveness of concepts

     familiar vs. unfamiliar languages     Fortran

     higher- vs. lower-level language productivity     importance of     Java     JavaScript

     Perl

     PHP

     productivity from

     programming into languages 2nd     Python     ratio of statements compared to C code, table of     SQL

     thinking, effects on     Visual Basicprogramming tools

    assembler listing tools [See construction, tools for; tools, programming]

     beautifiers

     build tools

     building your own     CASE tools

     checklist

     class-hierarchy generators     code libraries

     code tuning

     code-generation wizards     compilers

     cross-reference tools     data dictionaries

     debugging tools 2nd 3rd 4th

     dependency checkers

     design tools

     Diff tools

     disassemblers

     editing tools

     executable-code tools

     execution profiler tools

     fantasyland

     graphical design tools

     grep

     IDEs

     interface documentation     key points

     linkers     merge tools     metrics reporters

     multiple-file string searches

     preprocessors

     project-specific tools     purpose of

     quality analysis     refactoring tools     resources on     restructuring tools

     scripts

     semantics checkers

     source-code tools

     syntax checkers     templates     testing tools     tool-oriented environments

     translators     version control tools project types, prerequisites corresponding to

protected data

prototyping 2nd

Proximity, Principle of 2nd

pseudocode     algorithms, researching

     bad, example of

     benefits from     changing, efficiency of

     checking for errors

     checklist for PPP     classes, steps in creating

     coding below comments     coding from

     comments from 2nd

     data structure for routines

     declarations from

     defined

     designing routines

     error handling considerations

     example for routines

     functionality from libraries

     good, example of

     guidelines for effective use

     header comments for routines

     high-level comments from

     iterative refinement 2nd     key points for creating

     loop design     naming routines     performance considerations

     prerequisites

     problem definition

     refactoring     reviewing

     routines, steps in creating 2nd     testing, planning for Pseudocode Programming Process psychological distance

psychological factors

psychological set

public data members

pure blocks layout stylePython     description of     performance issues