Becoming a Better Programmer

A Handbook for People Who Care About Code

Publisher: O’Reilly Media
Final Release Date: October 2014
Pages: 362

A Handbook for People Who Care About Code

If you’re passionate about programming and want to get better at it, you’ve come to the right source. Code Craft author Pete Goodliffe presents a collection of useful techniques and approaches to the art and craft of programming that will help boost your career and your well-being.

Goodliffe presents sound advice that he’s learned in 15 years of professional programming. The book’s standalone chapters span the range of a software developer’s life—dealing with code, learning the trade, and improving performance—with no language or industry bias. Whether you’re a seasoned developer, a neophyte professional, or a hobbyist, you’ll find valuable tips in five independent categories:

  • Code-level techniques for crafting lines of code, testing, debugging, and coping with complexity
  • Practices, approaches, and attitudes: keep it simple, collaborate well, reuse, and create malleable code
  • Tactics for learning effectively, behaving ethically, finding challenges, and avoiding stagnation
  • Practical ways to complete things: use the right tools, know what “done” looks like, and seek help from colleagues
  • Habits for working well with others, and pursuing development as a social activity

About the Author

Pete Goodliffe

Pete Goodliffe is a programmer, a software development columnist, a musician, and author. He never stays at the same place in the software food chain – his projects range from OS implementation, through audio codecs, to multimedia applications; from embedded firmware, through iOS development, to desktop applications. He has a passion for curry and doesn’t wear shoes.

Pete’s popular development book Code Craft is a practical and entertaining investigation of the entire programming pursuit. In about 600 pages. No mean feat! It has been translated into many languages. He writes a magazine column called “Becoming a Better Programmer,” has contributed to several software development books, and regularly speaks on software development topics.

View Pete Goodliffe’s full profile page.


The animal on the cover of Becoming a Better Programmer is a two-winged flying fish (Exocoetidae). The flying fish can be distinguished by its unusually large pectoral fins. As the name suggests, it makes powerful, self-propelled leaps out of the water into the air by moving its tail up to 70 times per second. In the early 1900s, flying fish were studied as models for developing airplanes. Once in the air, it spreads its wing-like fins and tilts them upward, which enables it to glide for considerable distances. The pectoral fin, or “wing,” has a similar aerodynamic shape as a bird wing. At the end of the glide, it either reenters the sea by folding the pectoral fins, or dropping its tail into the water to lift itself for another glide. The record is 45 seconds in flight, as recorded by a Japanese television crew in 2008.

Their ability to fly into the air is often used as a defense mechanism against predators, which include dolphins, tuna, marlin, birds, squids, and porpoises. They’re commercially fished by gillnetting in Japan, Vietnam, and China, and by dipnetting in Indonesia and India. In the Solomon Islands, flying fish are caught during flight in nets from outrigger canoes. Commercial fishing of this species is done in complete darkness when no moonlight is available, as the fish are attracted to lit torches. Flying fish feed mainly on plankton, and live in all of the oceans, mostly in warm, tropical or subtropical waters.

Many of the animals on O’Reilly covers are endangered; all of them are important to the world. To learn more about how you can help, go to .

Table of Contents

  1. Care about the Code
    1. you.write(code);
  2. Keeping Up Appearances
    1. Presentation Is Powerful
    2. It’s About Communication
    3. Layout
    4. Names
    5. Making Yourself Presentable
    6. Conclusion
  3. Write Less Code!
    1. Why Should We Care?
    2. Flappy Logic
    3. Duplication
    4. Dead Code
    6. Verbosity
    7. Bad Design
    8. Whitespace
    9. So What Do We Do?
    10. Conclusion
  4. Improve Code by Removing It
    1. Code Indulgence
    2. It’s Not Bad, It’s Inevitable
    3. So What?
    4. Waking the Dead
    5. Surgical Extraction
    6. Conclusion
  5. The Ghost of a Codebase Past
    1. Presentation
    2. The State of the Art
    3. Idioms
    4. Design Decisions
    5. Bugs
    6. Conclusion
  6. Navigating a Route
    1. A Little Help from My Friends
    2. Look for Clues
    3. Learn by Doing
    4. Conclusion
  7. Wallowing in Filth
    1. Smell the Signs
    2. Wading into the Cesspit
    3. The Survey Says…
    4. Working in the Sandpit
    5. Cleaning Up Messes
    6. Making Adjustments
    7. Bad Code? Bad Programmers?
  8. Don’t Ignore That Error!
    1. The Mechanism
    2. The Madness
    3. The Mitigation
    4. Conclusion
  9. Expect the Unexpected
    1. Errors
    2. Threading
    3. Shutdown
    4. The Moral of the Story
  10. Bug Hunting
    1. An Economic Concern
    2. An Ounce of Prevention
    3. Bug Hunting
    4. Non-Reproducible Bugs
    5. Conclusion
  11. Testing Times
    1. Why Test?
    2. Types of Tests
    3. When to Write Tests
    4. When to Run Tests
    5. What to Test
    6. Good Tests
    7. What Does a Test Look Like?
    8. The Structure of Tests
    9. No Code Is an Island
    10. Conclusion
  12. Coping with Complexity
    1. Blobs
    2. Case Study: Reducing Blob Complexity
    3. Lines
    4. And Finally: People
    5. Conclusion
  13. A Tale of Two Systems
    1. The Messy Metropolis
    2. Design Town
    3. So What?
    4. Practice Makes Perfect
  14. Software Development Is…
    1. This Software (Food)stuff
    2. Software Development Is…an Art
    3. Software Development Is…a Science
    4. Software Development Is…a Sport
    5. Software Development Is…Child’s Play
    6. Software Development Is…a Chore
    7. Metaphor Overload
  15. Playing by the Rules
    1. We Need More Rules!
    2. Set the Rules
  16. Keep It Simple
    1. Simple Designs
    2. Simple Lines of Code
    3. Keeping It Simple, Not Stupid
    4. Assumptions Can Reduce Simplicity
    5. Avoid Premature Optimisation
    6. Sufficiently Simple
    7. A Simple Conclusion
  17. Use Your Brain
    1. Don’t Be Stupid
    2. Avoid Mindlessness
    3. You Are Allowed to Think!
  18. Nothing Is Set in Stone
    1. Fearless Change
    2. Change Your Attitude
    3. Make the Change
    4. Plus ça Change
  19. A Case for Code Reuse
    1. Reuse Case 1: The Copy-Pasta
    2. Reuse Case 2: Design for Reuse
    3. Reuse Case 3: Promote and Refactor
    4. Reuse Case 4: Buy In, or Reinvent the Wheel
  20. Effective Version Control
    1. Use It or Lose It
    2. Pick One, Any One
    3. Storing the Right Things
    4. Use Version Control Well
    5. Branches: Seeing the Wood for the Trees
    6. The Home for Your Code
    7. Conclusion
  21. Getting One Past the Goalpost
    1. Software Development: Shovelling Manure
    2. A False Dichotomy
    3. Fix the Team to Fix the Code
    4. Releasing a Build to QA
    5. On Getting a Fault Report
    6. Our Differences Make Us Stronger
    7. Pieces of the Puzzle
  22. The Curious Case of the Frozen Code
    1. Hunting the Code Freeze
    2. A New World Order
    3. Forms of Freeze
    4. Branches Make It Work
    5. But It’s Not Really Frozen!
    6. Length of the Freeze
    7. Feel the Freeze
    8. The End Draws Near
    9. Antifreeze
    10. Conclusion
  23. Please Release Me
    1. Part of the Process
    2. A Cog in the Machine
    3. Release Early and Often
    4. And There’s More…
    5. Getting Personal
  24. Live to Love to Learn
    1. What to Learn?
    2. Learning to Learn
    3. Learning Models
    4. Teach to Learn
    5. Act to Learn
    6. What Have We Learnt?
  25. Test-Driven Developers
    1. Driving the Point Home
    2. Success Breeds Complacency
    3. Testing Times
    4. Test-Driven Developers
    5. Conclusion
  26. Relish the Challenge
    1. It’s the Motivation
    2. What’s the Challenge?
    3. Don’t Do It!
    4. Get Challenged
    5. Conclusion
  27. Avoid Stagnation
    1. Your Skills Are Your Investment
    2. An Exercise for the Reader
    3. Job Security
  28. The Ethical Programmer
    1. Attitude to Code
    2. Legal Issues
    3. Attitude to People
    4. The Hippocodic Oath
    5. Conclusion
  29. A Love for Languages
    1. Love All Languages
    2. Love Your Language
    3. Cultivating Your Language Relationship
    4. A Perfect Metaphor?
    5. Conclusion
  30. Posturing Programmers
    1. Basic Computer Posture
    2. Eye Strain
    3. Conclusion
    4. Getting Things Done
  31. Smarter, Not Harder
    1. Pick Your Battles
    2. Battle Tactics
    3. Conclusion
  32. It’s Done When It’s Done
    1. Are We There Yet?
    2. Developing Backwards: Decomposition
    3. Define “Done”
    4. Just Do It
  33. This Time I’ve Got It…
    1. Desert Island Development
    2. Stood at the Bottom of the Mountain
    3. The People Pursuit
  34. People Power
    1. What to Do
    2. Know Your Experts
    3. 20/20 Hindsight
  35. It’s the Thought That Accounts
    1. Stretching the Metaphor
    2. Accountability Counts
    3. Code++
    4. Making It Work
    5. Setting the Standard
    6. The Next Steps
    7. Conclusion
  36. Speak Up!
    1. Code Is Communication
    2. Interpersonal Communication
    3. Talking of Teams
    4. Talking to the Customer
    5. Other Communication
    6. Conclusion
  37. Many-festos
    1. A Generic Manifesto for Software Development
    2. OK, OK
    3. The Manyfestos
    4. But, Really?
    5. The Punchline
  38. An Ode to Code
    1. Coding Is a People Problem

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s