- Code Complete, Second Edition
- Preface
- Acknowledgments
- About the Author
- I. Laying the Foundation
- 1. Welcome to Software Construction
- 2. Metaphors for a Richer Understanding of Software Development
- 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
- Typical Architectural Components
- Program Organization
- Major Classes
- Data Design
- Business Rules
- User Interface Design
- Resource Management
- Security
- Performance
- Scalability
- Interoperability
- Internationalization/Localization
- Input/Output
- Error Processing
- Fault Tolerance
- Architectural Feasibility
- Overengineering
- Buy-vs.-Build Decisions
- Reuse Decisions
- Change Strategy
- General Architectural Quality
- Typical Architectural Components
- 3.6. Amount of Time to Spend on Upstream Prerequisites
- Additional Resources
- Key Points
- 4. Key Construction Decisions
- II. Creating High-Quality Code
- 5. Design in Construction
- 5.1. Design Challenges
- 5.2. Key Design Concepts
- 5.3. Design Building Blocks: Heuristics
- Find Real-World Objects
- Form Consistent Abstractions
- Encapsulate Implementation Details
- Inherit—When Inheritance Simplifies the Design
- Hide Secrets (Information Hiding)
- Identify Areas Likely to Change
- Keep Coupling Loose
- Look for Common Design Patterns
- Other Heuristics
- Summary of Design Heuristics
- Guidelines for Using Heuristics
- 5.4. Design Practices
- 5.5. Comments on Popular Methodologies
- Additional Resources
- Key Points
- 6. Working Classes
- 7. High-Quality Routines
- 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
- 9. The Pseudocode Programming Process
- 5. Design in Construction
- III. Variables
- 10. General Issues in Using Variables
- 11. The Power of Variable Names
- 12. Fundamental Data Types
- 13. Unusual Data Types
- IV. Statements
- 14. Organizing Straight-Line Code
- 15. Using Conditionals
- 16. Controlling Loops
- 17. Unusual Control Structures
- 18. Table-Driven Methods
- 19. General Control Issues
- 19.1. Boolean Expressions
- Using true and false for Boolean Tests
- Making Complicated Expressions Simple
- Forming Boolean Expressions Positively
- Using Parentheses to Clarify Boolean Expressions
- Knowing How Boolean Expressions Are Evaluated
- Writing Numeric Expressions in Number-Line Order
- Guidelines for Comparisons to 0
- Common Problems with 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
- 19.1. Boolean Expressions
- V. Code Improvements
- 20. The Software-Quality Landscape
- 21. Collaborative Construction
- 22. Developer Testing
- 23. Debugging
- 24. Refactoring
- 25. Code-Tuning Strategies
- 26. Code-Tuning Techniques
- VI. System Considerations
- 27. How Program Size Affects Construction
- 28. Managing Construction
- 29. Integration
- 30. Programming Tools
- VII. Software Craftsmanship
- 31. Layout and Style
- 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
- 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
- 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
- 35. Where to Find More Information
- Bibliography
- Index
- About the Author
At one time or another, someone thought that each of the following control structures was a good idea:
Unrestricted use of gotos
Ability to compute a goto target dynamically and jump to the computed location
Ability to use goto to jump from the middle of one routine into the middle of another routine
Ability to call a routine with a line number or label that allowed execution to begin somewhere in the middle of the routine
Ability to have the program generate code on the fly and then execute the code it just wrote
At one time, each of these ideas was regarded as acceptable or even desirable, even though now they all look hopelessly quaint, outdated, or dangerous. The field of software development has advanced largely through restricting what programmers can do with their code. Consequently, I view unconventional control structures with strong skepticism. I suspect that the majority of constructs in this chapter will eventually find their way onto the programmer's scrap heap along with computed goto labels, variable routine entry points, self-modifying code, and other structures that favored flexibility and convenience over structure and the ability to manage complexity.
-
No Comment