index_P

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 use
parameters 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 parameters
patterns
    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 for
pointers
     & (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, checking
polymorphism
    case statements, replacing with [See object-oriented programming, polymorphism]
     defined
     language-specific rules
     nested ifs, converting to
polynomial expressions
portability
     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, development
productivity
     effects of good construction practice
     industry average
     size of projects, effects on
professional development
professional organizations
program 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 Basic
programming 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 style
Python
     description of
     performance issues