book

Code Complete, 2nd Edition

Name: Code Complete, 2nd Edition
Author: Steve McConnell
ISBN: 9780735619678

by Steve McConnell

June 2004

Intermediate to advanced

992 pages

37h 55m

English

Cisco Press

Read now

Unlock full access

Code Complete, Second Edition
Contents at a Glance
Table of Contents
Preface
Who Should Read This Book?Experienced ProgrammersTechnical LeadsSelf-Taught ProgrammersStudents
Where Else Can You Find This Information?
Key Benefits of This Handbook
Why This Handbook Was Written
The Topic of Construction Has Been NeglectedConstruction Is ImportantNo 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 CodeSoftware Farming: Growing a SystemSoftware Oyster Farming: System AccretionSoftware Construction: Building SoftwareApplying Software Techniques: The Intellectual ToolboxCombining MetaphorsAdditional Resources
Key Points
3. Measure Twice, Cut Once: Upstream Prerequisites
3.1. Importance of PrerequisitesDo Prerequisites Apply to Modern Software Projects?Causes of Incomplete PreparationUtterly Compelling and Foolproof Argument for Doing Prerequisites Before ConstructionAppeal to LogicAppeal to AnalogyAppeal to DataBoss-Readiness Test
3.2. Determine the Kind of Software You're Working On
Iterative Approaches' Effect on PrerequisitesChoosing Between Iterative and Sequential Approaches
3.3. Problem-Definition Prerequisite
3.4. Requirements Prerequisite
Why Have Official Requirements?The Myth of Stable RequirementsHandling Requirements Changes During Construction
3.5. Architecture Prerequisite
Typical Architectural ComponentsProgram OrganizationMajor ClassesData DesignBusiness RulesUser Interface DesignResource ManagementSecurityPerformanceScalabilityInteroperabilityInternationalization/LocalizationInput/OutputError ProcessingFault ToleranceArchitectural FeasibilityOverengineeringBuy-vs.-Build DecisionsReuse DecisionsChange StrategyGeneral Architectural Quality
3.6. Amount of Time to Spend on Upstream Prerequisites
Additional Resources
RequirementsSoftware ArchitectureGeneral Software-Development Approaches
Key Points
4. Key Construction Decisions
4.1. Choice of Programming LanguageLanguage DescriptionsAdaAssembly LanguageCC++C#CobolFortranJavaJavaScriptPerlPHPPythonSQLVisual Basic
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 ChallengesDesign Is a Wicked ProblemDesign Is a Sloppy Process (Even If it Produces a Tidy Result)Design Is About Tradeoffs and PrioritiesDesign Involves RestrictionsDesign Is NondeterministicDesign Is a Heuristic ProcessDesign Is Emergent
5.2. Key Design Concepts
Software's Primary Technical Imperative: Managing ComplexityAccidental and Essential DifficultiesImportance of Managing ComplexityHow to Attack ComplexityDesirable Characteristics of a DesignLevels of DesignLevel 1: Software SystemLevel 2: Division into Subsystems or PackagesLevel 3: Division into ClassesLevel 4: Division into RoutinesLevel 5: Internal Routine Design
5.3. Design Building Blocks: Heuristics
Find Real-World ObjectsForm Consistent AbstractionsEncapsulate Implementation DetailsInherit—When Inheritance Simplifies the DesignHide Secrets (Information Hiding)Secrets and the Right to PrivacyAn Example of Information HidingTwo Categories of SecretsBarriers to Information HidingValue of Information HidingIdentify Areas Likely to ChangeAnticipating Different Degrees of ChangeKeep Coupling LooseCoupling CriteriaKinds of CouplingLook for Common Design PatternsOther HeuristicsAim for Strong CohesionBuild HierarchiesFormalize Class ContractsAssign ResponsibilitiesDesign for TestAvoid FailureChoose Binding Time ConsciouslyMake Central Points of ControlConsider Using Brute ForceDraw a DiagramKeep Your Design ModularSummary of Design HeuristicsGuidelines for Using Heuristics
5.4. Design Practices
IterateDivide and ConquerTop-Down and Bottom-Up Design ApproachesArgument for Top DownArgument for Bottom UpNo Argument, ReallyExperimental PrototypingCollaborative DesignHow Much Design Is Enough?Capturing Your Design Work
5.5. Comments on Popular Methodologies
Additional Resources
Software Design, GeneralSoftware Design TheoryDesign PatternsDesign in GeneralStandards
Key Points
6. Working Classes
6.1. Class Foundations: Abstract Data Types (ADTs)Example of the Need for an ADTBenefits of Using ADTsMore Examples of ADTsHandling Multiple Instances of Data with ADTs in Non-Object-Oriented EnvironmentsADTs and Classes
6.2. Good Class Interfaces
Good AbstractionGood Encapsulation
6.3. Design and Implementation Issues
Containment ("has a" Relationships)Inheritance ("is a" Relationships)Multiple InheritanceWhy Are There So Many Rules for Inheritance?Member Functions and DataConstructors
6.4. Reasons to Create a Class
Classes to AvoidSummary of Reasons to Create a Class
6.5. Language-Specific Issues
6.6. Beyond Classes: Packages
Additional Resources
Classes in GeneralC++JavaVisual Basic
Key Points
7. High-Quality Routines
7.1. Valid Reasons to Create a RoutineOperations That Seem Too Simple to Put Into RoutinesSummary 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 ProcedureSetting the Function's Return Value
7.7. Macro Routines and Inline Routines
Limitations on the Use of Macro RoutinesInline Routines
Key Points
8. Defensive Programming
8.1. Protecting Your Program from Invalid Inputs
8.2. Assertions
Building Your Own Assertion MechanismGuidelines for Using Assertions
8.3. Error-Handling Techniques
Robustness vs. CorrectnessHigh-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 VersionIntroduce Debugging Aids EarlyUse Offensive ProgrammingPlan 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
SecurityAssertionsExceptions
Key Points
9. The Pseudocode Programming Process
9.1. Summary of Steps in Building Classes and RoutinesSteps in Creating a ClassSteps in Building a Routine
9.2. Pseudocode for Pros
9.3. Constructing Routines by Using the PPP
Design the RoutineCode the RoutineCheck the CodeClean Up LeftoversRepeat Steps as Needed
9.4. Alternatives to the PPP
Key Points
III. Variables
10. General Issues in Using Variables
10.1. Data LiteracyThe Data Literacy TestAdditional Resources on Data Types
10.2. Making Variable Declarations Easy
Implicit Declarations
10.3. Guidelines for Initializing Variables
10.4. Scope
Localize References to VariablesKeep Variables "Live" for as Short a Time as PossibleMeasuring the Live Time of a VariableGeneral Guidelines for Minimizing ScopeComments 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 NamesThe Most Important Naming ConsiderationProblem OrientationOptimum Name LengthThe Effect of Scope on Variable NamesComputed-Value Qualifiers in Variable NamesCommon Opposites in Variable Names
11.2. Naming Specific Types of Data
Naming Loop IndexesNaming Status VariablesNaming Temporary VariablesNaming Boolean VariablesNaming Enumerated TypesNaming Constants
11.3. The Power of Naming Conventions
Why Have Conventions?When You Should Have a Naming ConventionDegrees of Formality
11.4. Informal Naming Conventions
Guidelines for a Language-Independent ConventionGuidelines for Language-Specific ConventionsC ConventionsC++ ConventionsJava ConventionsVisual Basic ConventionsMixed-Language Programming ConsiderationsSample Naming Conventions
11.5. Standardized Prefixes
User-Defined Type AbbreviationsSemantic PrefixesAdvantages of Standardized Prefixes
11.6. Creating Short Names That Are Readable
General Abbreviation GuidelinesPhonetic AbbreviationsComments 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 PointersLocation in MemoryKnowledge of How to Interpret the ContentsGeneral Tips on PointersC++-Pointer PointersC-Pointer Pointers
13.3. Global Data
Common Problems with Global DataReasons to Use Global DataUse Global Data Only as a Last ResortUsing Access Routines Instead of Global DataAdvantages of Access RoutinesHow to Use Access RoutinesHow 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 BottomGrouping Related Statements
Key Points
15. Using Conditionals
15.1. if StatementsPlain if-then StatementsChains of if-then-else Statements
15.2. case Statements
Choosing the Most Effective Ordering of CasesTips for Using case Statements
Key Points
16. Controlling Loops
16.1. Selecting the Kind of LoopWhen to Use a while LoopLoop with Test at the BeginningLoop with Test at the EndWhen to Use a Loop-With-Exit LoopNormal Loop-With-Exit LoopsAbnormal Loop-With-Exit LoopsWhen to Use a for LoopWhen to Use a foreach Loop
16.2. Controlling the Loop
Entering the LoopProcessing the Middle of the LoopExiting the LoopExiting Loops EarlyChecking EndpointsUsing Loop VariablesHow 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 RecursionTips for Using Recursion
17.3. goto
The Argument Against gotosThe Argument for gotosThe Phony goto DebateError Processing and gotosComparison of the Approachesgotos and Sharing Code in an else ClauseSummary of Guidelines for Using gotos
17.4. Perspective on Unusual Control Structures
Additional Resources
Returnsgotos
Key Points
18. Table-Driven Methods
18.1. General Considerations in Using Table-Driven MethodsTwo Issues in Using Table-Driven Methods
18.2. Direct Access Tables
Days-in-Month ExampleInsurance Rates ExampleFlexible-Message-Format ExampleLogic-Based ApproachObject-Oriented ApproachTable-Driven ApproachFudging 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 ExpressionsUsing true and false for Boolean TestsMaking Complicated Expressions SimpleForming Boolean Expressions PositivelyUsing Parentheses to Clarify Boolean ExpressionsKnowing How Boolean Expressions Are EvaluatedWriting Numeric Expressions in Number-Line OrderGuidelines for Comparisons to 0Common 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 ProgrammingSequenceSelectionIteration
19.6. Control Structures and Complexity
How Important Is Complexity?General Guidelines for Reducing ComplexityHow to Measure ComplexityWhat to Do with Your Complexity MeasurementOther 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 ProcessSetting Objectives
20.3. Relative Effectiveness of Quality Techniques
Percentage of Defects DetectedCost of Finding DefectsCost 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 PracticesCollaborative Construction Complements Other Quality-Assurance TechniquesCollaborative Construction Provides Mentoring in Corporate Culture and Programming ExpertiseCollective Ownership Applies to All Forms of Collaborative ConstructionCollaboration Applies As Much Before Construction As After
21.2. Pair Programming
Keys to Success with Pair ProgrammingBenefits of Pair Programming
21.3. Formal Inspections
What Results Can You Expect from Inspections?Roles During an InspectionGeneral Procedure for an InspectionFine-Tuning the InspectionEgos in InspectionsInspections and Code CompleteInspection Summary
21.4. Other Kinds of Collaborative Development Practices
Walk-ThroughsWhat Results Can You Expect from a Walk-Through?Code ReadingDog-and-Pony Shows
Comparison of Collaborative Construction Techniques
Additional Resources
Pair ProgrammingInspectionsRelevant Standards
Key Points
22. Developer Testing
22.1. Role of Developer Testing in Software QualityTesting 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 TestingStructured Basis TestingData-Flow TestingCombinations of Data StatesEquivalence PartitioningError GuessingBoundary AnalysisCompound BoundariesClasses of Bad DataClasses of Good DataUse Test Cases That Make Hand-Checks Convenient
22.4. Typical Errors
Which Classes Contain the Most Errors?Errors by ClassificationProportion of Errors Resulting from Faulty ConstructionHow Many Errors Should You Expect to Find?Errors in Testing Itself
22.5. Test-Support Tools
Building Scaffolding to Test Individual ClassesDiff ToolsTest-Data GeneratorsCoverage MonitorsData Recorder/LoggingSymbolic DebuggersSystem PerturbersError Databases
22.6. Improving Your Testing
Planning to TestRetesting (Regression Testing)Automated Testing
22.7. Keeping Test Records
Personal Test RecordsAdditional ResourcesTestingTest ScaffoldingTest First DevelopmentRelevant Standards
Key Points
23. Debugging
23.1. Overview of Debugging IssuesRole of Debugging in Software QualityVariations in Debugging PerformanceDefects as OpportunitiesAn Ineffective ApproachThe Devil's Guide to DebuggingDebugging by Superstition
23.2. Finding a Defect
The Scientific Method of DebuggingStabilize the ErrorLocate the Source of the ErrorTips for Finding DefectsBrute-Force DebuggingSyntax Errors
23.3. Fixing a Defect
23.4. Psychological Considerations in Debugging
How "Psychological Set" Contributes to Debugging BlindnessHow "Psychological Distance" Can Help
23.5. Debugging Tools—Obvious and Not-So-Obvious
Source-Code ComparatorsCompiler Warning MessagesExtended Syntax and Logic CheckingExecution ProfilersTest Frameworks/ScaffoldingDebuggers
Additional Resources
Key Points
24. Refactoring
24.1. Kinds of Software EvolutionPhilosophy of Software Evolution
24.2. Introduction to Refactoring
Reasons to RefactorReasons Not to Refactor
24.3. Specific Refactorings
Data-Level RefactoringsStatement-Level RefactoringsRoutine-Level RefactoringsClass Implementation RefactoringsClass Interface RefactoringsSystem-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 OverviewQuality Characteristics and PerformancePerformance and Code TuningProgram RequirementsProgram DesignClass and Routine DesignOperating-System InteractionsCode CompilationHardwareCode Tuning
25.2. Introduction to Code Tuning
The Pareto PrincipleOld Wives' TalesWhen to TuneCompiler Optimizations
25.3. Kinds of Fat and Molasses
Common Sources of InefficiencyRelative 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
PerformanceAlgorithms and Data Types
Key Points
26. Code-Tuning Techniques
26.1. LogicStop Testing When You Know the AnswerOrder Tests by FrequencyCompare Performance of Similar Logic StructuresSubstitute Table Lookups for Complicated ExpressionsUse Lazy Evaluation
26.2. Loops
UnswitchingJammingUnrollingMinimizing the Work Inside LoopsSentinel ValuesPutting the Busiest Loop on the InsideStrength Reduction
26.3. Data Transformations
Use Integers Rather Than Floating-Point NumbersUse the Fewest Array Dimensions PossibleMinimize Array ReferencesUse Supplementary IndexesString-Length IndexIndependent, Parallel Index StructureUse Caching
26.4. Expressions
Exploit Algebraic IdentitiesUse Strength ReductionInitialize at Compile TimeBe Wary of System RoutinesUse the Correct Type of ConstantsPrecompute ResultsEliminate 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 SizePrograms, Products, Systems, and System ProductsMethodology and Size
Additional Resources
Key Points
28. Managing Construction
28.1. Encouraging Good CodingConsiderations in Setting StandardsTechniques for Encouraging Good CodingThe Role of This Book
28.2. Configuration Management
What Is Configuration Management?Requirements and Design ChangesSoftware Code ChangesTool VersionsMachine ConfigurationsBackup PlanAdditional Resources on Configuration Management
28.3. Estimating a Construction Schedule
Estimation ApproachesEstimating the Amount of ConstructionInfluences on ScheduleEstimation vs. ControlWhat to Do If You're BehindAdditional 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 QualityIndividual VariationTeam VariationReligious IssuesPhysical EnvironmentAdditional Resources on Programmers as Human Beings
28.6. Managing Your Manager
Additional Resources on Managing ConstructionRelevant Standards
Key Points
29. Integration
29.1. Importance of the Integration Approach
29.2. Integration Frequency—Phased or Incremental?
Phased IntegrationIncremental IntegrationBenefits of Incremental Integration
29.3. Incremental Integration Strategies
Top-Down IntegrationBottom-Up IntegrationSandwich IntegrationRisk-Oriented IntegrationFeature-Oriented IntegrationT-Shaped IntegrationSummary of Integration Approaches
29.4. Daily Build and Smoke Test
What Kinds of Projects Can Use the Daily Build Process?Continuous Integration
Additional Resources
IntegrationIncrementalism
Key Points
30. Programming Tools
30.1. Design Tools
30.2. Source-Code Tools
EditingIntegrated Development Environments (IDEs)Multiple-File String Searching and ReplacingDiff ToolsMerge ToolsSource-Code BeautifiersInterface Documentation ToolsTemplatesCross-Reference ToolsClass Hierarchy GeneratorsAnalyzing Code QualityPicky Syntax and Semantics CheckersMetrics ReportersRefactoring Source CodeRefactorersRestructurersCode TranslatorsVersion ControlData Dictionaries
30.3. Executable-Code Tools
Code CreationCompilers and LinkersBuild ToolsCode LibrariesCode-Generation WizardsSetup and InstallationPreprocessorsDebuggingTestingCode TuningExecution ProfilersAssembler Listings and Disassemblers
30.4. Tool-Oriented Environments
30.5. Building Your Own Programming Tools
Project-Specific ToolsScripts
30.6. Tool Fantasyland
Additional Resources
Key Points
VII. Software Craftsmanship
31. Layout and Style
31.1. Layout FundamentalsLayout ExtremesThe Fundamental Theorem of FormattingHuman and Computer Interpretations of a ProgramHow Much Is Good Layout Worth?Layout as ReligionObjectives of Good LayoutHow to Put the Layout Objectives to Use
31.2. Layout Techniques
White SpaceParentheses
31.3. Layout Styles
Pure BlocksEmulating Pure BlocksUsing begin-end Pairs (Braces) to Designate Block BoundariesEndline LayoutWhich Style Is Best?
31.4. Laying Out Control Structures
Fine Points of Formatting Control-Structure BlocksOther Considerations
31.5. Laying Out Individual Statements
Statement LengthUsing Spaces for ClarityFormatting Continuation LinesUsing Only One Statement Per LineLaying Out Data Declarations
31.6. Laying Out Comments
31.7. Laying Out Routines
31.8. Laying Out Classes
Laying Out Class InterfacesLaying Out Class ImplementationsLaying 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 CommentsRepeat of the CodeExplanation of the CodeMarker in the CodeSummary of the CodeDescription of the Code's IntentInformation That Cannot Possibly Be Expressed by the Code ItselfCommenting EfficientlyOptimum Number of Comments
32.5. Commenting Techniques
Commenting Individual LinesEndline Comments and Their ProblemsWhen to Use Endline CommentsCommenting Paragraphs of CodeCommenting Data DeclarationsCommenting Control StructuresCommenting RoutinesCommenting Classes, Files, and ProgramsGeneral Guidelines for Class DocumentationGeneral Guidelines for File DocumentationThe Book Paradigm for Program Documentation
32.6. IEEE Standards
Software-Development StandardsSoftware Quality-Assurance StandardsManagement StandardsOverview 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
PersistenceExperienceGonzo 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 AbstractionLevel 0: Operating-System Operations and Machine InstructionsLevel 1: Programming-Language Structures and ToolsLevel 2: Low-Level Implementation StructuresLevel 3: Low-Level Problem-Domain TermsLevel 4: High-Level Problem-Domain TermsLow-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 OraclesEclecticismExperimentation
Key Points
35. Where to Find More Information
35.1. Information About Software Construction
35.2. Topics Beyond Construction
Overview MaterialSoftware-Engineering OverviewsOther Annotated Bibliographies
35.3. Periodicals
Lowbrow Programmer MagazinesHighbrow Programmer JournalsSpecial-Interest PublicationsProfessional PublicationsPopular-Market Publications
35.4. A Software Developer's Reading Plan
Introductory LevelPractitioner LevelProfessional Level
35.5. Joining a Professional Organization
Bibliography
Index
About the Author

Content preview from Code Complete, 2nd Edition

Floating-Point Numbers

The main consideration in using floating-point numbers is that many fractional decimal numbers can't be represented accurately using the 1s and 0s available on a digital computer. Nonterminating decimals like 1/3 or 1/7 can usually be represented to only 7 or 15 digits of accuracy. In my version of Microsoft Visual Basic, a 32-bit floating-point representation of 1/3 equals 0.33333330. It's accurate to 7 digits. This is accurate enough for most purposes but inaccurate enough to trick you sometimes.

Following are a few specific guidelines for using floating-point numbers:

Avoid additions and subtractions on numbers that have ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0735619670Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills