index_C

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 2nd
character, 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 as
cohesion
     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 types
compilers
    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 types
complexity
     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 debugging
configuration 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 5th
constants
     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 checklist
construction 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, expanding
constructors
     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 of
conventions, 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 of
coverage
     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