Muutke küpsiste eelistusi

Preventative Programming Techniques: Avoid and Correct Common Mistakes [Multiple-component retail product]

  • Formaat: Multiple-component retail product, 322 pages, Illustrations, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 25-Mar-2003
  • Kirjastus: Charles River Media
  • ISBN-10: 1584502576
  • ISBN-13: 9781584502579
Teised raamatud teemal:
  • Multiple-component retail product
  • Hind: 57,24 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
  • Formaat: Multiple-component retail product, 322 pages, Illustrations, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 25-Mar-2003
  • Kirjastus: Charles River Media
  • ISBN-10: 1584502576
  • ISBN-13: 9781584502579
Teised raamatud teemal:
From his experience in computer animation and game development, Hawkins is convinced that the many errors software development seems heir to are really just different versions of a few that programmers repeat over and over in various guise. He writes for both new and experienced programmer who use at least one programming language. The disk contains source code for examples, and tools for more efficient programming. Annotation (c) Book News, Inc., Portland, OR (booknews.com)

Preventative Programming Techniques provides programmers with a clear and intelligent approach to detecting, preventing, and correcting the most common mistakes. It includes practical ways to reduce problems that occur every day, and provides methods for correcting problems that already exist. Using a medical metaphor, each of the common problems is presented as an illness. Each illness is then presented in a structured approach that includes a basic description, common symptoms, prevention methods, cures, and related illnesses to look for.The majority of the principles and practices espoused are language independent and focus on instructing programmers how to detect and avoid problems. It also includes guidelines on determining when and how to refactor or rewrite code. Some of the major and minor illnesses found throughout programming, include premature optimization, CAP (cut and paste) epidemic, NIH (not invented here) syndrome, complexification, oversimplification, docuphobia, and more. If you're a programmer, you've made these mistakes or you've had to deal with code that has them in it.To learn how to prevent and fix these problems, check out all of the illnessesyou're sure to find insightful tips for your own projects. Novice programmers will benefit greatly from reading through each category of illness from start to finish, and experienced programmers will benefit from the insightful tips and anecdotes.
Acknowledgments xvii
About the Author xix
Introduction xxi
PART I Major Illnesses
1(156)
Premature Optimization
3(56)
Description
3(1)
Symptoms
3(33)
General Symptoms
4(32)
Prevention
36(9)
The Simplest Technique: Do Not Optimize
37(1)
K.I.S.S. (Keep It Simple, Stupid)
37(1)
High-Level Languages
38(1)
Encapsulation and Abstraction
39(1)
Strategy Pattern
40(1)
Editors: Tools of the Trade
41(4)
Cure
45(8)
When to Refactor
46(1)
Profile, Profile, Profile
46(4)
Importance of Testing
50(2)
Special Case: Libraries
52(1)
Related Illnesses
53(1)
First Aid Kit
54(2)
Summary
56(3)
CAP Epidemic
59(54)
Description
59(1)
Symptoms
59(7)
The Bug Came Back
60(2)
Search and Replace
62(1)
What Does That Mean: CAP Symptoms in Documentation
63(1)
Obscure Bug Hunt
63(2)
Too Many Directions
65(1)
Information Duplication
66(1)
Prevention
66(38)
Know Your Code
66(3)
Know Your Libraries
69(2)
High-Level Languages
71(25)
Automation
96(2)
Avoiding Asset Duplication
98(2)
Generative Programming
100(4)
Cure
104(6)
When to Refactor
104(1)
Refactoring Tools
105(4)
Beyond Refactoring Tools
109(1)
Importance of Testing Redux
109(1)
Related Illnesses
110(1)
First Aid Kit
110(1)
Summary
111(2)
NIH Syndrome
113(44)
Description
113(1)
Symptoms
113(7)
Control Fanatics by Nature
114(1)
What Are We Afraid Of?
114(4)
What Should We Be Afraid Of?
118(2)
Prevention
120(28)
What Are Middleware and Open Source?
120(1)
Technical Support
121(1)
Research
122(2)
Flavors: Types of Reusable Code
124(9)
Expanding the Selection with .NET
133(3)
Strategy Pattern Revisited
136(4)
Adapters, Bridges, and Facades
140(8)
Cure
148(5)
Sacred Code
148(1)
When to Refactor
149(1)
One Step at a Time
150(1)
Conformance
150(1)
Workarounds
151(1)
Did We Mention the Importance of Testing?
152(1)
Related Illnesses
153(1)
First Aid Kit
153(1)
Summary
154(3)
PART II Minor Illnesses
157(146)
Complexification
159(18)
Description
159(1)
Symptoms
159(6)
Poor Readability
159(3)
Invisible Functionality
162(2)
Return of the Nifty Algorithm
164(1)
Emergent Bugs
165(1)
Prevention
165(7)
K.I.S.S.
165(1)
Know the Options
166(1)
Start Small
167(1)
The Right Language
168(3)
Try Explaining That
171(1)
Refactoring for Prevention
172(1)
Cure
172(2)
When to Refactor
172(1)
Simplify the Algorithm
173(1)
Simplify the Code
174(1)
Related Illnesses
174(1)
First Aid Kit
175(1)
Summary
175(2)
Over Simplification
177(12)
Description
177(1)
Symptoms
177(3)
So Simple It Does Not Do Anything
177(1)
Shifting Complexity
178(1)
Do Not Touch
178(2)
Prevention
180(2)
Completeness
180(1)
Realistic Design
181(1)
Winds of Change
181(1)
Cure
182(4)
More Sacred Code
182(1)
When to Refactor
183(1)
Up and Down
183(2)
Libraries for Reuse
185(1)
Related Illnesses
186(1)
First Aid Kit
186(1)
Summary
187(2)
Docuphobia
189(26)
Description
189(1)
Symptoms
189(6)
What, How, and Why?
189(4)
Not That Way
193(2)
Prevention
195(12)
Too Little vs. Too Much
195(1)
Document in the Code
195(7)
Coding Standards
202(1)
Avoiding Duplication
203(2)
Automation
205(2)
Maintenance
207(1)
Cure
207(2)
Analyze
207(1)
Query
208(1)
Refactoring
208(1)
Related Illnesses
209(1)
First Aid Kit
209(3)
Summary
212(3)
i
215(18)
Description
215(1)
Symptoms
215(3)
Comment Required?
216(1)
Dangers of Context
217(1)
Prevention
218(8)
Editors: Tools of the Trade
218(2)
Naming Conventions
220(1)
Everyday Language
221(5)
Cure
226(4)
Read the Code
226(1)
Comments to Code
226(4)
Related Illnesses
230(1)
First Aid Kit
231(1)
Summary
231(2)
Hardcode
233(18)
Description
233(1)
Symptoms
233(4)
Strings and Numbers
233(1)
More CAP
234(1)
Localization
235(2)
Prevention
237(7)
Standard Data Source
237(1)
XML
238(5)
Asset Management
243(1)
Cure
244(4)
When to Refactor
244(1)
Context Highlighting
245(1)
Collection
245(3)
Run Time vs. Compile Time
248(1)
Related Illnesses
248(1)
First Aid Kit
249(1)
Summary
249(2)
Brittle Bones
251(18)
Description
251(1)
Symptoms
252(8)
Too Minimal
252(4)
Too Complete
256(2)
Lack of Consistency
258(2)
Spiraling
260(1)
Prevention
260(4)
Design
261(2)
Balance
263(1)
Cure
264(1)
Stop
264(1)
Learn
264(1)
Refactor
265(1)
Related Illnesses
265(1)
First Aid Kit
266(1)
Summary
266(3)
Requirement Deficiency
269(14)
Description
269(1)
Symptoms
269(3)
Vagueness
269(1)
Too Many Options
270(1)
History
271(1)
Nagging Feeling
271(1)
Prevention
272(6)
Communication
272(2)
Paper Trail
274(1)
Checklist
275(2)
Internal Technical Requirements
277(1)
Flexibility
277(1)
Cure
278(2)
Get Feedback
278(1)
Incorporate
279(1)
Bargain
279(1)
Refactor
279(1)
Related Illnesses
280(1)
First Aid Kit
280(1)
Summary
281(2)
Myopia
283(8)
Description
283(1)
Symptoms
283(1)
Shortcuts
283(1)
Prevention
284(2)
Think Ahead
284(1)
Statistics
284(1)
Education
285(1)
Cure
286(2)
Refactor
287(1)
Reboot
287(1)
Avoid Crunching
288(1)
Related Illnesses
288(1)
First Aid Kit
289(1)
Summary
290(1)
Conclusion
291(12)
Common Techniques
291(8)
Toward the Programmer's DSM-IV
299(1)
Community
300(3)
APPENDIX A Teamwork
303(6)
Made for People
303(1)
Made by People
304(2)
Point of View
306(3)
APPENDIX B References
309(2)
APPENDIX C About the CD-ROM
311(1)
Source
311(1)
Tools
311(1)
System Requirements
312