思维导图备注

Code Complete - Steve McConnell
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

Commenting Classes, Files, and Programs

浏览 4 扫码
  • 小字体
  • 中字体
  • 大字体
2022-02-24 00:47:17
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • SPECIAL OFFER: Upgrade this ebook with O’Reilly
  • Preface
    • Who Should Read This Book?
      • Experienced Programmers
      • Technical Leads
      • Self-Taught Programmers
      • Students
    • Where Else Can You Find This Information?
    • Key Benefits of This Handbook
    • Why This Handbook Was Written
      • The Topic of Construction Has Been Neglected
      • Construction Is Important
      • No Comparable Book Is Available
    • Author Note
  • Acknowledgments
  • About the Author
    • Steve McConnell
  • 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
      • Key Points
    • 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
        • Software Penmanship: Writing Code
        • Software Farming: Growing a System
        • Software Oyster Farming: System Accretion
        • Software Construction: Building Software
        • Applying Software Techniques: The Intellectual Toolbox
        • Combining Metaphors
        • Additional Resources
      • Key Points
    • 3. Measure Twice, Cut Once: Upstream Prerequisites
      • 3.1. Importance of Prerequisites
        • Do Prerequisites Apply to Modern Software Projects?
        • Causes of Incomplete Preparation
        • Utterly Compelling and Foolproof Argument for Doing Prerequisites Before Construction
      • 3.2. Determine the Kind of Software You're Working On
        • Iterative Approaches' Effect on Prerequisites
        • Choosing Between Iterative and Sequential Approaches
      • 3.3. Problem-Definition Prerequisite
      • 3.4. Requirements Prerequisite
        • Why Have Official Requirements?
        • The Myth of Stable Requirements
        • Handling Requirements Changes During Construction
      • 3.5. Architecture Prerequisite
        • Typical Architectural Components
      • 3.6. Amount of Time to Spend on Upstream Prerequisites
      • Additional Resources
        • Requirements
        • Software Architecture
        • General Software-Development Approaches
      • Key Points
    • 4. Key Construction Decisions
      • 4.1. Choice of Programming Language
        • Language Descriptions
      • 4.2. Programming Conventions
      • 4.3. Your Location on the Technology Wave
        • Example of Programming into a Language
      • 4.4. Selection of Major Construction Practices
      • Key Points
  • II. Creating High-Quality Code
    • 5. Design in Construction
      • 5.1. Design Challenges
        • Design Is a Wicked Problem
        • Design Is a Sloppy Process (Even If it Produces a Tidy Result)
        • Design Is About Tradeoffs and Priorities
        • Design Involves Restrictions
        • Design Is Nondeterministic
        • Design Is a Heuristic Process
        • Design Is Emergent
      • 5.2. Key Design Concepts
        • Software's Primary Technical Imperative: Managing Complexity
        • Desirable Characteristics of a Design
        • Levels of Design
      • 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
        • Iterate
        • Divide and Conquer
        • Top-Down and Bottom-Up Design Approaches
        • Experimental Prototyping
        • Collaborative Design
        • How Much Design Is Enough?
        • Capturing Your Design Work
      • 5.5. Comments on Popular Methodologies
      • Additional Resources
        • Software Design, General
        • Software Design Theory
        • Design Patterns
        • Design in General
        • Standards
      • Key Points
    • 6. Working Classes
      • 6.1. Class Foundations: Abstract Data Types (ADTs)
        • Example of the Need for an ADT
        • Benefits of Using ADTs
        • More Examples of ADTs
        • Handling Multiple Instances of Data with ADTs in Non-Object-Oriented Environments
        • ADTs and Classes
      • 6.2. Good Class Interfaces
        • Good Abstraction
        • Good Encapsulation
      • 6.3. Design and Implementation Issues
        • Containment ("has a" Relationships)
        • Inheritance ("is a" Relationships)
        • Member Functions and Data
        • Constructors
      • 6.4. Reasons to Create a Class
        • Classes to Avoid
        • Summary of Reasons to Create a Class
      • 6.5. Language-Specific Issues
      • 6.6. Beyond Classes: Packages
      • Additional Resources
        • Classes in General
        • C++
        • Java
        • Visual Basic
      • Key Points
    • 7. High-Quality Routines
      • 7.1. Valid Reasons to Create a Routine
        • Operations That Seem Too Simple to Put Into Routines
        • Summary of 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
        • When to Use a Function and When to Use a Procedure
        • Setting the Function's Return Value
      • 7.7. Macro Routines and Inline Routines
        • Limitations on the Use of Macro Routines
        • Inline Routines
      • Key Points
    • 8. Defensive Programming
      • 8.1. Protecting Your Program from Invalid Inputs
      • 8.2. Assertions
        • Building Your Own Assertion Mechanism
        • Guidelines for Using Assertions
      • 8.3. Error-Handling Techniques
        • Robustness vs. Correctness
        • High-Level Design Implications of Error Processing
      • 8.4. Exceptions
      • 8.5. Barricade Your Program to Contain the Damage Caused by Errors
        • Relationship Between Barricades and Assertions
      • 8.6. Debugging Aids
        • Don't Automatically Apply Production Constraints to the Development Version
        • Introduce Debugging Aids Early
        • Use Offensive Programming
        • Plan to Remove Debugging Aids
      • 8.7. Determining How Much Defensive Programming to Leave in Production Code
      • 8.8. Being Defensive About Defensive Programming
      • Additional Resources
        • Security
        • Assertions
        • Exceptions
      • Key Points
    • 9. The Pseudocode Programming Process
      • 9.1. Summary of Steps in Building Classes and Routines
        • Steps in Creating a Class
        • Steps in Building a Routine
      • 9.2. Pseudocode for Pros
      • 9.3. Constructing Routines by Using the PPP
        • Design the Routine
        • Code the Routine
        • Check the Code
        • Clean Up Leftovers
        • Repeat Steps as Needed
      • 9.4. Alternatives to the PPP
      • Key Points
  • III. Variables
    • 10. General Issues in Using Variables
      • 10.1. Data Literacy
        • The Data Literacy Test
        • Additional Resources on Data Types
      • 10.2. Making Variable Declarations Easy
        • Implicit Declarations
      • 10.3. Guidelines for Initializing Variables
      • 10.4. Scope
        • Localize References to Variables
        • Keep Variables "Live" for as Short a Time as Possible
        • General Guidelines for Minimizing Scope
        • Comments on Minimizing 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
    • 11. The Power of Variable Names
      • 11.1. Considerations in Choosing Good Names
        • The Most Important Naming Consideration
        • Problem Orientation
        • Optimum Name Length
        • The Effect of Scope on Variable Names
        • Computed-Value Qualifiers in Variable Names
        • Common Opposites in Variable Names
      • 11.2. Naming Specific Types of Data
        • Naming Loop Indexes
        • Naming Status Variables
        • Naming Temporary Variables
        • Naming Boolean Variables
        • Naming Enumerated Types
        • Naming Constants
      • 11.3. The Power of Naming Conventions
        • Why Have Conventions?
        • When You Should Have a Naming Convention
        • Degrees of Formality
      • 11.4. Informal Naming Conventions
        • Guidelines for a Language-Independent Convention
        • Guidelines for Language-Specific Conventions
        • Mixed-Language Programming Considerations
        • Sample Naming Conventions
      • 11.5. Standardized Prefixes
        • User-Defined Type Abbreviations
        • Semantic Prefixes
        • Advantages of Standardized Prefixes
      • 11.6. Creating Short Names That Are Readable
        • General Abbreviation Guidelines
        • Phonetic Abbreviations
        • Comments on Abbreviations
      • 11.7. Kinds of Names to Avoid
      • Key Points
    • 12. Fundamental Data Types
      • 12.1. Numbers in General
      • 12.2. Integers
      • 12.3. Floating-Point Numbers
      • 12.4. Characters and Strings
        • Strings in C
      • 12.5. Boolean Variables
      • 12.6. Enumerated Types
        • If Your Language Doesn't Have Enumerated Types
      • 12.7. Named Constants
      • 12.8. Arrays
      • 12.9. Creating Your Own Types (Type Aliasing)
        • Why Are the Examples of Creating Your Own Types in Pascal and Ada?
        • Guidelines for Creating Your Own Types
      • Key Points
    • 13. Unusual Data Types
      • 13.1. Structures
      • 13.2. Pointers
        • Paradigm for Understanding Pointers
        • General Tips on Pointers
        • C++-Pointer Pointers
        • C-Pointer Pointers
      • 13.3. Global Data
        • Common Problems with Global Data
        • Reasons to Use Global Data
        • Use Global Data Only as a Last Resort
        • Using Access Routines Instead of Global Data
        • How to Reduce the Risks of Using Global Data
      • Additional Resources
      • Key Points
  • 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
        • Making Code Read from Top to Bottom
        • Grouping Related Statements
      • Key Points
    • 15. Using Conditionals
      • 15.1. if Statements
        • Plain if-then Statements
        • Chains of if-then-else Statements
      • 15.2. case Statements
        • Choosing the Most Effective Ordering of Cases
        • Tips for Using case Statements
      • Key Points
    • 16. Controlling Loops
      • 16.1. Selecting the Kind of Loop
        • When to Use a while Loop
        • When to Use a Loop-With-Exit Loop
        • When to Use a for Loop
        • When to Use a foreach Loop
      • 16.2. Controlling the Loop
        • Entering the Loop
        • Processing the Middle of the Loop
        • Exiting the Loop
        • Checking Endpoints
        • Using Loop Variables
        • How Long Should a Loop Be?
      • 16.3. Creating Loops Easily—From the Inside Out
      • 16.4. Correspondence Between Loops and Arrays
      • Key Points
    • 17. Unusual Control Structures
      • 17.1. Multiple Returns from a Routine
      • 17.2. Recursion
        • Example of Recursion
        • Tips for Using Recursion
      • 17.3. goto
        • The Argument Against gotos
        • The Argument for gotos
        • The Phony goto Debate
        • Error Processing and gotos
        • gotos and Sharing Code in an else Clause
        • Summary of Guidelines for Using gotos
      • 17.4. Perspective on Unusual Control Structures
      • Additional Resources
        • Returns
        • gotos
      • Key Points
    • 18. Table-Driven Methods
      • 18.1. General Considerations in Using Table-Driven Methods
        • Two Issues in Using Table-Driven Methods
      • 18.2. Direct Access Tables
        • Days-in-Month Example
        • Insurance Rates Example
        • Flexible-Message-Format Example
        • Logic-Based Approach
        • Object-Oriented Approach
        • Table-Driven Approach
        • Fudging Lookup Keys
      • 18.3. Indexed Access Tables
      • 18.4. Stair-Step Access Tables
      • 18.5. Other Examples of Table Lookups
      • Key Points
    • 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
        • Summary of Techniques for Reducing Deep Nesting
      • 19.5. A Programming Foundation: Structured Programming
        • The Three Components of Structured Programming
      • 19.6. Control Structures and Complexity
        • How Important Is Complexity?
        • General Guidelines for Reducing Complexity
        • Other Kinds of Complexity
      • Key Points
  • V. Code Improvements
    • 20. The Software-Quality Landscape
      • 20.1. Characteristics of Software Quality
      • 20.2. Techniques for Improving Software Quality
        • Development Process
        • Setting Objectives
      • 20.3. Relative Effectiveness of Quality Techniques
        • Percentage of Defects Detected
        • Cost of Finding Defects
        • Cost of Fixing Defects
      • 20.4. When to Do Quality Assurance
      • 20.5. The General Principle of Software Quality
      • Additional Resources
        • Relevant Standards
      • Key Points
    • 21. Collaborative Construction
      • 21.1. Overview of Collaborative Development Practices
        • Collaborative Construction Complements Other Quality-Assurance Techniques
        • Collaborative Construction Provides Mentoring in Corporate Culture and Programming Expertise
        • Collective Ownership Applies to All Forms of Collaborative Construction
        • Collaboration Applies As Much Before Construction As After
      • 21.2. Pair Programming
        • Keys to Success with Pair Programming
        • Benefits of Pair Programming
      • 21.3. Formal Inspections
        • What Results Can You Expect from Inspections?
        • Roles During an Inspection
        • General Procedure for an Inspection
        • Egos in Inspections
        • Inspections and Code Complete
        • Inspection Summary
      • 21.4. Other Kinds of Collaborative Development Practices
        • Walk-Throughs
        • Code Reading
        • Dog-and-Pony Shows
      • Comparison of Collaborative Construction Techniques
      • Additional Resources
        • Pair Programming
        • Inspections
        • Relevant Standards
      • Key Points
    • 22. Developer Testing
      • 22.1. Role of Developer Testing in Software Quality
        • Testing During Construction
      • 22.2. Recommended Approach to Developer Testing
        • Test First or Test Last?
        • Limitations of Developer Testing
      • 22.3. Bag of Testing Tricks
        • Incomplete Testing
        • Structured Basis Testing
        • Data-Flow Testing
        • Equivalence Partitioning
        • Error Guessing
        • Boundary Analysis
        • Classes of Bad Data
        • Classes of Good Data
        • Use Test Cases That Make Hand-Checks Convenient
      • 22.4. Typical Errors
        • Which Classes Contain the Most Errors?
        • Errors by Classification
        • Proportion of Errors Resulting from Faulty Construction
        • How Many Errors Should You Expect to Find?
        • Errors in Testing Itself
      • 22.5. Test-Support Tools
        • Building Scaffolding to Test Individual Classes
        • Diff Tools
        • Test-Data Generators
        • Coverage Monitors
        • Data Recorder/Logging
        • Symbolic Debuggers
        • System Perturbers
        • Error Databases
      • 22.6. Improving Your Testing
        • Planning to Test
        • Retesting (Regression Testing)
        • Automated Testing
      • 22.7. Keeping Test Records
        • Personal Test Records
        • Additional Resources
        • Testing
        • Test Scaffolding
        • Test First Development
        • Relevant Standards
      • Key Points
    • 23. Debugging
      • 23.1. Overview of Debugging Issues
        • Role of Debugging in Software Quality
        • Variations in Debugging Performance
        • Defects as Opportunities
        • An Ineffective Approach
      • 23.2. Finding a Defect
        • The Scientific Method of Debugging
        • Tips for Finding Defects
        • Syntax Errors
      • 23.3. Fixing a Defect
      • 23.4. Psychological Considerations in Debugging
        • How "Psychological Set" Contributes to Debugging Blindness
        • How "Psychological Distance" Can Help
      • 23.5. Debugging Tools—Obvious and Not-So-Obvious
        • Source-Code Comparators
        • Compiler Warning Messages
        • Extended Syntax and Logic Checking
        • Execution Profilers
        • Test Frameworks/Scaffolding
        • Debuggers
      • Additional Resources
      • Key Points
    • 24. Refactoring
      • 24.1. Kinds of Software Evolution
        • Philosophy of Software Evolution
      • 24.2. Introduction to Refactoring
        • Reasons to Refactor
        • Reasons Not to Refactor
      • 24.3. Specific Refactorings
        • Data-Level Refactorings
        • Statement-Level Refactorings
        • Routine-Level Refactorings
        • Class Implementation Refactorings
        • Class Interface Refactorings
        • System-Level Refactorings
      • 24.4. Refactoring Safely
        • Bad Times to Refactor
      • 24.5. Refactoring Strategies
      • Additional Resources
      • Key Points
    • 25. Code-Tuning Strategies
      • 25.1. Performance Overview
        • Quality Characteristics and Performance
        • Performance and Code Tuning
      • 25.2. Introduction to Code Tuning
        • The Pareto Principle
        • Old Wives' Tales
        • When to Tune
        • Compiler Optimizations
      • 25.3. Kinds of Fat and Molasses
        • Common Sources of Inefficiency
        • Relative Performance Costs of Common Operations
      • 25.4. Measurement
        • Measurements Need to Be Precise
      • 25.5. Iteration
      • 25.6. Summary of the Approach to Code Tuning
      • Additional Resources
        • Performance
        • Algorithms and Data Types
      • Key Points
    • 26. Code-Tuning Techniques
      • 26.1. Logic
        • Stop Testing When You Know the Answer
        • Order Tests by Frequency
        • Compare Performance of Similar Logic Structures
        • Substitute Table Lookups for Complicated Expressions
        • Use Lazy Evaluation
      • 26.2. Loops
        • Unswitching
        • Jamming
        • Unrolling
        • Minimizing the Work Inside Loops
        • Sentinel Values
        • Putting the Busiest Loop on the Inside
        • Strength Reduction
      • 26.3. Data Transformations
        • Use Integers Rather Than Floating-Point Numbers
        • Use the Fewest Array Dimensions Possible
        • Minimize Array References
        • Use Supplementary Indexes
        • Use Caching
      • 26.4. Expressions
        • Exploit Algebraic Identities
        • Use Strength Reduction
        • Initialize at Compile Time
        • Be Wary of System Routines
        • Use the Correct Type of Constants
        • Precompute Results
        • Eliminate Common Subexpressions
      • 26.5. Routines
        • Rewrite Routines Inline
      • 26.6. Recoding in a Low-Level Language
      • 26.7. The More Things Change, the More They Stay the Same
      • Additional Resources
      • Key Points
  • 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
        • Activity Proportions and Size
        • Programs, Products, Systems, and System Products
        • Methodology and Size
      • Additional Resources
      • Key Points
    • 28. Managing Construction
      • 28.1. Encouraging Good Coding
        • Considerations in Setting Standards
        • Techniques for Encouraging Good Coding
        • The Role of This Book
      • 28.2. Configuration Management
        • What Is Configuration Management?
        • Requirements and Design Changes
        • Software Code Changes
        • Tool Versions
        • Machine Configurations
        • Backup Plan
        • Additional Resources on Configuration Management
      • 28.3. Estimating a Construction Schedule
        • Estimation Approaches
        • Estimating the Amount of Construction
        • Influences on Schedule
        • Estimation vs. Control
        • What to Do If You're Behind
        • Additional Resources on Software Estimation
      • 28.4. Measurement
        • Additional Resources on Software Measurement
      • 28.5. Treating Programmers as People
        • How Do Programmers Spend Their Time?
        • Variation in Performance and Quality
        • Religious Issues
        • Physical Environment
        • Additional Resources on Programmers as Human Beings
      • 28.6. Managing Your Manager
        • Additional Resources on Managing Construction
        • Relevant Standards
      • Key Points
    • 29. Integration
      • 29.1. Importance of the Integration Approach
      • 29.2. Integration Frequency—Phased or Incremental?
        • Phased Integration
        • Incremental Integration
        • Benefits of Incremental Integration
      • 29.3. Incremental Integration Strategies
        • Top-Down Integration
        • Bottom-Up Integration
        • Sandwich Integration
        • Risk-Oriented Integration
        • Feature-Oriented Integration
        • T-Shaped Integration
        • Summary of Integration Approaches
      • 29.4. Daily Build and Smoke Test
        • What Kinds of Projects Can Use the Daily Build Process?
        • Continuous Integration
      • Additional Resources
        • Integration
        • Incrementalism
      • Key Points
    • 30. Programming Tools
      • 30.1. Design Tools
      • 30.2. Source-Code Tools
        • Editing
        • Analyzing Code Quality
        • Refactoring Source Code
        • Version Control
        • Data Dictionaries
      • 30.3. Executable-Code Tools
        • Code Creation
        • Debugging
        • Testing
        • Code Tuning
      • 30.4. Tool-Oriented Environments
      • 30.5. Building Your Own Programming Tools
        • Project-Specific Tools
        • Scripts
      • 30.6. Tool Fantasyland
      • Additional Resources
      • Key Points
  • VII. Software Craftsmanship
    • 31. Layout and Style
      • 31.1. Layout Fundamentals
        • Layout Extremes
        • The Fundamental Theorem of Formatting
        • Human and Computer Interpretations of a Program
        • How Much Is Good Layout Worth?
        • Layout as Religion
        • Objectives of Good Layout
      • 31.2. Layout Techniques
        • White Space
        • Parentheses
      • 31.3. Layout Styles
        • Pure Blocks
        • Emulating Pure Blocks
        • Using begin-end Pairs (Braces) to Designate Block Boundaries
        • Endline Layout
        • Which Style Is Best?
      • 31.4. Laying Out Control Structures
        • Fine Points of Formatting Control-Structure Blocks
        • Other Considerations
      • 31.5. Laying Out Individual Statements
        • Statement Length
        • Using Spaces for Clarity
        • Formatting Continuation Lines
        • Using Only One Statement Per Line
        • Laying Out Data Declarations
      • 31.6. Laying Out Comments
      • 31.7. Laying Out Routines
      • 31.8. Laying Out Classes
        • Laying Out Class Interfaces
        • Laying Out Class Implementations
        • Laying Out Files and Programs
      • Additional Resources
      • Key Points
    • 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
        • Kinds of Comments
        • Commenting Efficiently
        • Optimum Number of Comments
      • 32.5. Commenting Techniques
        • Commenting Individual Lines
        • Commenting Paragraphs of Code
        • Commenting Data Declarations
        • Commenting Control Structures
        • Commenting Routines
        • Commenting Classes, Files, and Programs
      • 32.6. IEEE Standards
        • Software-Development Standards
        • Software Quality-Assurance Standards
        • Management Standards
        • Overview of 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
        • Persistence
        • Experience
        • Gonzo Programming
      • 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
        • Separating a Program into Levels of Abstraction
        • Low-Level Techniques for Working in 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
        • Software Oracles
        • Eclecticism
        • Experimentation
      • Key Points
    • 35. Where to Find More Information
      • 35.1. Information About Software Construction
      • 35.2. Topics Beyond Construction
        • Overview Material
        • Software-Engineering Overviews
        • Other Annotated Bibliographies
      • 35.3. Periodicals
        • Lowbrow Programmer Magazines
        • Highbrow Programmer Journals
        • Special-Interest Publications
      • 35.4. A Software Developer's Reading Plan
        • Introductory Level
        • Practitioner Level
        • Professional Level
      • 35.5. Joining a Professional Organization
  • Bibliography
  • Index
  • SPECIAL OFFER: Upgrade this ebook with O’Reilly
暂无相关搜索结果！
    展开/收起文章目录

    二维码

    手机扫一扫，轻松掌上学

    《Code Complete - Steve McConnell》电子书下载

    请下载您需要的格式的电子书，随时随地，享受学习的乐趣！
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度