Becoming a Better Programmer by Goodliffe, Pete -- Read -- Imperial Library of Trantor

Index

Also by Pete Goodliffe Introduction

What’s Covered? Who Should Read This? The Structure A Note for Mentors Safari® Books Online How to Contact Us Acknowledgments

1. Care About the Code I. you.write(code); 2. Keeping Up Appearances

Presentation Is Powerful It’s About Communication Layout

Structure Well Consistency

Names

Avoid Redundancy Be Clear Be Idiomatic Be Accurate

Making Yourself Presentable Conclusion

3. Write Less Code!

Why Should We Care? Flappy Logic Duplication Dead Code Comments Verbosity Bad Design Whitespace So What Do We Do? Conclusion

4. Improve Code by Removing It

Code Indulgence It’s Not Bad, It’s Inevitable So What? Waking the Dead Surgical Extraction Conclusion

5. The Ghost of a Codebase Past

Presentation The State of the Art Idioms Design Decisions Bugs Conclusion

6. Navigating a Route

A Little Help from My Friends Look for Clues Learn by Doing

Low-Hanging Fruit Inspect the Code Study, Then Act Test First Housekeeping Document What You Find

Conclusion

7. Wallowing in Filth

Smell the Signs Wading into the Cesspit The Survey Says… Working in the Sandpit Cleaning Up Messes Making Adjustments Bad Code? Bad Programmers?

8. Don’t Ignore That Error!

The Mechanism The Madness The Mitigation Conclusion

9. Expect the Unexpected

Errors Threading Shutdown The Moral of the Story

10. Bug Hunting

An Economic Concern An Ounce of Prevention Bug Hunting

Lay Traps Learn to Binary Chop Employ Software Archaeology Test, Test, Test Invest in Sharp Tools Remove Code to Exclude It from Cause Analysis Cleanliness Prevents Infection Oblique Strategies Don’t Rush Away

Non-Reproducible Bugs Conclusion

11. Testing Times

Why Test?

Shortening the Feedback Loop Code That Tests Code Who Writes the Tests?

Types of Tests When to Write Tests When to Run Tests What to Test Good Tests What Does a Test Look Like?

Test Names

The Structure of Tests

Maintain the Tests Picking a Test Framework

No Code Is an Island Conclusion

12. Coping with Complexity

Blobs Case Study: Reducing Blob Complexity Lines And Finally: People Conclusion

13. A Tale of Two Systems

The Messy Metropolis

Incomprehensiblity Lack of Cohesion Unnecessary Coupling Code Problems Problems Outside the Code A Postcard from the Metropolis

Design Town

Locating Functionality Consistency Growing the Architecture Deferring Design Decisions Maintaining Quality Managing Technical Debt Tests Shape Design Time for Design Working with the Design

So What?

II. Practice Makes Perfect 14. Software Development Is…

This Software (Food)stuff Software Development Is…an Art Software Development Is…a Science Software Development Is…a Sport Software Development Is…Child’s Play Software Development Is…a Chore Metaphor Overload

15. Playing by the Rules

We Need More Rules! Set the Rules

16. Keep It Simple

Simple Designs

Simple to Use Prevents Misuse Size Matters Shorter Code Paths Stability

Simple Lines of Code Keeping It Simple, Not Stupid Assumptions Can Reduce Simplicity Avoid Premature Optimisation Sufficiently Simple A Simple Conclusion

17. Use Your Brain

Don’t Be Stupid Avoid Mindlessness You Are Allowed to Think!

18. Nothing Is Set in Stone

Fearless Change Change Your Attitude Make the Change

Design for Change Tools for Change Pick Your Battles

Plus ça Change

19. A Case for Code Reuse

Reuse Case 1: The Copy-Pasta Reuse Case 2: Design for Reuse Reuse Case 3: Promote and Refactor Reuse Case 4: Buy In, or Reinvent the Wheel

20. Effective Version Control

Use It or Lose It Pick One, Any One Storing the Right Things

Answer One: Store Everything Answer Two: Store as Little as Possible Storing Software Releases Repository Layout

Use Version Control Well

Make Atomic Commits Sending the Right Messages Craft Good Commits

Branches: Seeing the Wood for the Trees The Home for Your Code Conclusion

21. Getting One Past the Goalpost

Software Development: Shovelling Manure A False Dichotomy Fix the Team to Fix the Code Releasing a Build to QA

Test Your Work First Release with Intent More Haste, Less Speed Automate Respect

On Getting a Fault Report Our Differences Make Us Stronger Pieces of the Puzzle

22. The Curious Case of the Frozen Code

Hunting the Code Freeze A New World Order Forms of Freeze Branches Make It Work But It’s Not Really Frozen! Length of the Freeze Feel the Freeze The End Draws Near Antifreeze Conclusion

23. Please Release Me

Part of the Process A Cog in the Machine

Step 1: Initiate the Release Step 2: Prepare the Release Step 3: Build the Release Step 4: Package the Release Step 5: Deploy the Release

Release Early and Often And There’s More…

III. Getting Personal 24. Live to Love to Learn

What to Learn? Learning to Learn Learning Models

The Knowledge Portfolio

Teach to Learn Act to Learn What Have We Learnt?

25. Test-Driven Developers

Driving the Point Home Success Breeds Complacency Testing Times Test-Driven Developers Conclusion

26. Relish the Challenge

It’s the Motivation What’s the Challenge? Don’t Do It! Get Challenged Conclusion

27. Avoid Stagnation

Your Skills Are Your Investment An Exercise for the Reader Job Security

28. The Ethical Programmer

Attitude to Code Legal Issues Attitude to People

Teammates Manager Employer Yourself

The Hippocodic Oath Conclusion

29. A Love for Languages

Love All Languages Love Your Language Cultivating Your Language Relationship

Love and Respect Commitment Communication Patience Shared Values

A Perfect Metaphor? Conclusion

30. Posturing Programmers

Basic Computer Posture

The Debugging Posture When It’s Really Going Badly The All-Nighter Intervention from Above The All-Clear Design Time

Eye Strain Conclusion

IV. Getting Things Done 31. Smarter, Not Harder

Pick Your Battles Battle Tactics

Reuse Wisely Make It Someone Else’s Problem Only Do What You Have To Put It on a Spike Prioritise What’s Really Required? One Thing at a Time Keep It Small (and Simple) Don’t Defer and Store Up Problems Automate Error Prevention Communicate Avoid Burnout Power Tools

Conclusion

32. It’s Done When It’s Done

Are We There Yet? Developing Backwards: Decomposition Define “Done” Just Do It

33. This Time I’ve Got It…

Desert Island Development Stood at the Bottom of the Mountain

V. The People Pursuit 34. People Power

What to Do Know Your Experts 20/20 Hindsight

35. It’s the Thought That Accounts

Stretching the Metaphor Accountability Counts Code++ Making It Work Setting the Standard The Next Steps Conclusion

36. Speak Up!

Code Is Communication

Talking to the Machines Talking to the Animals Talking to Tools

Interpersonal Communication

Ways to Converse Watch Your Language Body Language Parallel Communication

Talking of Teams Talking to the Customer Other Communication Conclusion

37. Many-festos

A Generic Manifesto for Software Development OK, OK The Manyfestos But, Really? The Punchline

38. An Ode to Code

Coding Is a People Problem

Epilogue

Attitude Go Forth and Code

Index

← Prev
Back
Next →

← Prev
Back
Next →