---

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

ISBN: 0735619670
EAN: 2147483647

Year: 2003
Pages: 334

Authors: Steve McConnell

BUY ON AMAZON

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