Table of Contents

Code Complete, Second Edition
By Steve McConnell
...............................................
Publisher: Microsoft Press
Pub Date: June 09, 2004
Print ISBN: 0-7356-1967-0
Pages: 960

Table of Contents  | Index

---

		Copyright
		Preface
			Who Should Read This Book?
			Where Else Can You Find This Information?
			Key Benefits of This Handbook
			Why This Handbook Was Written
			Author Note
		Acknowledgments
		About the Author
			Steve McConnell
		Part I:  Laying the Foundation
			In this part:
			Chapter 1.  Welcome to Software Construction
				Section 1.1.  What Is Software Construction?
				Section 1.2.  Why Is Software Construction Important?
				Section 1.3.  How to Read This Book
				Key Points
			Chapter 2.  Metaphors for a Richer Understanding of Software Development
				Section 2.1.  The Importance of Metaphors
				Section 2.2.  How to Use Software Metaphors
				Section 2.3.  Common Software Metaphors
				Key Points
			Chapter 3.  Measure Twice, Cut Once: Upstream Prerequisites
				Section 3.1.  Importance of Prerequisites
				Section 3.2.  Determine the Kind of Software You're Working On
				Section 3.3.  Problem-Definition Prerequisite
				Section 3.4.  Requirements Prerequisite
				Section 3.5.  Architecture Prerequisite
				Section 3.6.  Amount of Time to Spend on Upstream Prerequisites
				Additional Resources
				Key Points
			Chapter 4.  Key Construction Decisions
				Section 4.1.  Choice of Programming Language
				Section 4.2.  Programming Conventions
				Section 4.3.  Your Location on the Technology Wave
				Section 4.4.  Selection of Major Construction Practices
				Key Points
		Part II:  Creating High-Quality Code
			In this part:
			Chapter 5.  Design in Construction
				Section 5.1.  Design Challenges
				Section 5.2.  Key Design Concepts
				Section 5.3.  Design Building Blocks: Heuristics
				Section 5.4.  Design Practices
				Section 5.5.  Comments on Popular Methodologies
				Additional Resources
				Key Points
			Chapter 6.  Working Classes
				Section 6.1.  Class Foundations: Abstract Data Types (ADTs)
				Section 6.2.  Good Class Interfaces
				Section 6.3.  Design and Implementation Issues
				Section 6.4.  Reasons to Create a Class
				Section 6.5.  Language-Specific Issues
				Section 6.6.  Beyond Classes: Packages
				Additional Resources
				Key Points
			Chapter 7.  High-Quality Routines
				Section 7.1.  Valid Reasons to Create a Routine
				Section 7.2.  Design at the Routine Level
				Section 7.3.  Good Routine Names
				Section 7.4.  How Long Can a Routine Be?
				Section 7.5.  How to Use Routine Parameters
				Section 7.6.  Special Considerations in the Use of Functions
				Section 7.7.  Macro Routines and Inline Routines
				Key Points
			Chapter 8.  Defensive Programming
				Section 8.1.  Protecting Your Program from Invalid Inputs
				Section 8.2.  Assertions
				Section 8.3.  Error-Handling Techniques
				Section 8.4.  Exceptions
				Section 8.5.  Barricade Your Program to Contain the Damage Caused by Errors
				Section 8.6.  Debugging Aids
				Section 8.7.  Determining How Much Defensive Programming to Leave in Production Code
				Section 8.8.  Being Defensive About Defensive Programming
				Additional Resources
				Key Points
			Chapter 9.  The Pseudocode Programming Process
				Section 9.1.  Summary of Steps in Building Classes and Routines
				Section 9.2.  Pseudocode for Pros
				Section 9.3.  Constructing Routines by Using the PPP
				Section 9.4.  Alternatives to the PPP
				Key Points
		Part III:  Variables
			In this part:
			Chapter 10.  General Issues in Using Variables
				Section 10.1.  Data Literacy
				Section 10.2.  Making Variable Declarations Easy
				Section 10.3.  Guidelines for Initializing Variables
				Section 10.4.  Scope
				Section 10.5.  Persistence
				Section 10.6.  Binding Time
				Section 10.7.  Relationship Between Data Types and Control Structures
				Section 10.8.  Using Each Variable for Exactly One Purpose
				Key Points
			Chapter 11.  The Power of Variable Names
				Section 11.1.  Considerations in Choosing Good Names
				Section 11.2.  Naming Specific Types of Data
				Section 11.3.  The Power of Naming Conventions
				Section 11.4.  Informal Naming Conventions
				Section 11.5.  Standardized Prefixes
				Section 11.6.  Creating Short Names That Are Readable
				Section 11.7.  Kinds of Names to Avoid
				Key Points
			Chapter 12.  Fundamental Data Types
				Section 12.1.  Numbers in General
				Section 12.2.  Integers
				Section 12.3.  Floating-Point Numbers
				Section 12.4.  Characters and Strings
				Section 12.5.  Boolean Variables
				Section 12.6.  Enumerated Types
				Section 12.7.  Named Constants
				Section 12.8.  Arrays
				Section 12.9.  Creating Your Own Types (Type Aliasing)
				Key Points
			Chapter 13.  Unusual Data Types
				Section 13.1.  Structures
				Section 13.2.  Pointers
				Section 13.3.  Global Data
				Additional Resources
				Key Points
		Part IV:  Statements
			In this part:
			Chapter 14.  Organizing Straight-Line Code
				Section 14.1.  Statements That Must Be in a Specific Order
				Section 14.2.  Statements Whose Order Doesn't Matter
				Key Points
			Chapter 15.  Using Conditionals
				Section 15.1.  if Statements
				Section 15.2.  case Statements
				Key Points
			Chapter 16.  Controlling Loops
				Section 16.1.  Selecting the Kind of Loop
				Section 16.2.  Controlling the Loop
				Section 16.3.  Creating Loops Easily From the Inside Out
				Section 16.4.  Correspondence Between Loops and Arrays
				Key Points
			Chapter 17.  Unusual Control Structures
				Section 17.1.  Multiple Returns from a Routine
				Section 17.2.  Recursion
				Section 17.3.  goto
				Section 17.4.  Perspective on Unusual Control Structures
				Additional Resources
				Key Points
			Chapter 18.  Table-Driven Methods
				Section 18.1.  General Considerations in Using Table-Driven Methods
				Section 18.2.  Direct Access Tables
				Section 18.3.  Indexed Access Tables
				Section 18.4.  Stair-Step Access Tables
				Section 18.5.  Other Examples of Table Lookups
				Key Points
			Chapter 19.  General Control Issues
				Section 19.1.  Boolean Expressions
				Section 19.2.  Compound Statements (Blocks)
				Section 19.3.  Null Statements
				Section 19.4.  Taming Dangerously Deep Nesting
				Section 19.5.  A Programming Foundation: Structured Programming
				Section 19.6.  Control Structures and Complexity
				Key Points
		Part V:  Code Improvements
			In this part:
			Chapter 20.  The Software-Quality Landscape
				Section 20.1.  Characteristics of Software Quality
				Section 20.2.  Techniques for Improving Software Quality
				Section 20.3.  Relative Effectiveness of Quality Techniques
				Section 20.4.  When to Do Quality Assurance
				Section 20.5.  The General Principle of Software Quality
				Additional Resources
				Key Points
			Chapter 21.  Collaborative Construction
				Section 21.1.  Overview of Collaborative Development Practices
				Section 21.2.  Pair Programming
				Section 21.3.  Formal Inspections
				Section 21.4.  Other Kinds of Collaborative Development Practices
				Comparison of Collaborative Construction Techniques
				Additional Resources
				Key Points
			Chapter 22.  Developer Testing
				Section 22.1.  Role of Developer Testing in Software Quality
				Section 22.2.  Recommended Approach to Developer Testing
				Section 22.3.  Bag of Testing Tricks
				Section 22.4.  Typical Errors
				Section 22.5.  Test-Support Tools
				Section 22.6.  Improving Your Testing
				Section 22.7.  Keeping Test Records
				Additional Resources
				Key Points
			Chapter 23.  Debugging
				Section 23.1.  Overview of Debugging Issues
				Section 23.2.  Finding a Defect
				Section 23.3.  Fixing a Defect
				Section 23.4.  Psychological Considerations in Debugging
				Section 23.5.  Debugging Tools Obvious and Not-So-Obvious
				Additional Resources
				Key Points
			Chapter 24.  Refactoring
				Section 24.1.  Kinds of Software Evolution
				Section 24.2.  Introduction to Refactoring
				Section 24.3.  Specific Refactorings
				Section 24.4.  Refactoring Safely
				Section 24.5.  Refactoring Strategies
				Additional Resources
				Key Points
			Chapter 25.  Code-Tuning Strategies
				Section 25.1.  Performance Overview
				Section 25.2.  Introduction to Code Tuning
				Section 25.3.  Kinds of Fat and Molasses
				Section 25.4.  Measurement
				Section 25.5.  Iteration
				Section 25.6.  Summary of the Approach to Code Tuning
				Additional Resources
				Key Points
			Chapter 26.  Code-Tuning Techniques
				Section 26.1.  Logic
				Section 26.2.  Loops
				Section 26.3.  Data Transformations
				Section 26.4.  Expressions
				Section 26.5.  Routines
				Section 26.6.  Recoding in a Low-Level Language
				Section 26.7.  The More Things Change, the More They Stay the Same
				Additional Resources
				Key Points
		Part VI:  System Considerations
			In this part:
			Chapter 27.  How Program Size Affects Construction
				Section 27.1.  Communication and Size
				Section 27.2.  Range of Project Sizes
				Section 27.3.  Effect of Project Size on Errors
				Section 27.4.  Effect of Project Size on Productivity
				Section 27.5.  Effect of Project Size on Development Activities
				Additional Resources
				Key Points
			Chapter 28.  Managing Construction
				Section 28.1.  Encouraging Good Coding
				Section 28.2.  Configuration Management
				Section 28.3.  Estimating a Construction Schedule
				Section 28.5.  Treating Programmers as People
				Section 28.6.  Managing Your Manager
				Key Points
			Chapter 29.  Integration
				Section 29.1.  Importance of the Integration Approach
				Section 29.2.  Integration Frequency Phased or Incremental?
				Section 29.3.  Incremental Integration Strategies
				Section 29.4.  Daily Build and Smoke Test
				Additional Resources
				Key Points
			Chapter 30.  Programming Tools
				Section 30.1.  Design Tools
				Section 30.2.  Source-Code Tools
				Section 30.3.  Executable-Code Tools
				Section 30.4.  Tool-Oriented Environments
				Section 30.5.  Building Your Own Programming Tools
				Section 30.6.  Tool Fantasyland
				Additional Resources
				Key Points
		Part VII:  Software Craftsmanship
			In this part:
			Chapter 31.  Layout and Style
				Section 31.1.  Layout Fundamentals
				Section 31.2.  Layout Techniques
				Section 31.3.  Layout Styles
				Section 31.4.  Laying Out Control Structures
				Section 31.5.  Laying Out Individual Statements
				Section 31.6.  Laying Out Comments
				Section 31.7.  Laying Out Routines
				Section 31.8.  Laying Out Classes
				Additional Resources
				Key Points
			Chapter 32.  Self-Documenting Code
				Section 32.1.  External Documentation
				Section 32.2.  Programming Style as Documentation
				Section 32.3.  To Comment or Not to Comment
				Section 32.4.  Keys to Effective Comments
				Section 32.5.  Commenting Techniques
				Section 32.6.  IEEE Standards
				Additional Resources
				Key Points
			Chapter 33.  Personal Character
				Section 33.1.  Isn't Personal Character Off the Topic?
				Section 33.2.  Intelligence and Humility
				Section 33.3.  Curiosity
				Section 33.4.  Intellectual Honesty
				Section 33.5.  Communication and Cooperation
				Section 33.6.  Creativity and Discipline
				Section 33.7.  Laziness
				Section 33.8.  Characteristics That Don't Matter As Much As You Might Think
				Section 33.9.  Habits
				Additional Resources
				Key Points
			Chapter 34.  Themes in Software Craftsmanship
				Section 34.1.  Conquer Complexity
				Section 34.2.  Pick Your Process
				Section 34.3.  Write Programs for People First, Computers Second
				Section 34.4.  Program into Your Language, Not in It
				Section 34.5.  Focus Your Attention with the Help of Conventions
				Section 34.6.  Program in Terms of the Problem Domain
				Section 34.7.  Watch for Falling Rocks
				Section 34.8.  Iterate, Repeatedly, Again and Again
				Section 34.9.  Thou Shalt Rend Software and Religion Asunder
				Key Points
			Chapter 35.  Where to Find More Information
				Section 35.1.  Information About Software Construction
				Section 35.2.  Topics Beyond Construction
				Section 35.3.  Periodicals
				Section 35.4.  A Software Developer's Reading Plan
				Section 35.5.  Joining a Professional Organization
		Bibliography
		Index