前言
致謝
核對(duì)清單
表目錄
圖目錄
Part I Laying the Foundation
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
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
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
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
Part II Creating High-Quality Code
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
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
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
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
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
Part III Variables
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
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
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)
13 Unusual Data Types
13.1 Structures
13.2 Pointers
13.3 Global Data
Part IV Statements
14 Organizing Straight-Line Code
14.1 Statements That Must Be in a Specific Order
14.2 Statements Whose Order Doesn’t Matter
15 Using Conditionals
15.1 if Statements
15.2 case Statements
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
17 Unusual Control Structures
17.1 Multiple Returns from a Routine
17.2 Recursion
17.3 goto
17.4 Perspective on Unusual Control Structures
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
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
Part V Code Improvements
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
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
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
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
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
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
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
Part VI System Considerations
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
28 Managing Construction
28.1 Encouraging Good Coding
28.2 Configuration Management
28.3 Estimating a Construction Schedule
28.4 Measurement
28.5 Treating Programmers as People
28.6 Managing Your Manager
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
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
Part VII Software Craftsmanship
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
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
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
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
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
鄂公網(wǎng)安備 42010302001612號(hào) 