Beefy Boxes and Bandwidth Generously Provided by pair Networks
Problems? Is your data what you think it is?
 
PerlMonks  

Comment on

( #3333=superdoc: print w/ replies, xml ) Need Help??

Vitals

The Pragmatic Programmer: From Journeyman to Master
by Andrew Hunt and David Thomas

Published October 1999 by Addison Wesley Longman, Inc.
ISBN: 020161622X
List Price: $34.95 U.S., $52.50 CAN
Edition Reviewed: First Edition, First printing
Web Site, Sample Chapter, and Errata: http://www.pragmaticprogrammer.com

Review Contents

Introduction

The Pragmatic Programmer, by Andrew Hunt and David Thomas, has an ambitious agenda, one stated in the first line in the Preface, This book will help you become a better programmer. It's a bold assertion and, given the number of books making similar claims, one to use as a benchmark against the book's success. By this, and any other benchmark, the book succeeds admirably.

Since I'm sometimes criticized for ambiguity in my posts, let me state this as clearly as I can: The Pragmatic Programmer (TPP for short) will help you become a better programmer...if you are receptive, open to its lessons, and willing to change.

TPP is not about Perl, though it refers to it often and with much respect. TPP outlines several ways to use Perl effectively in any project, regardless of the implementing language.

TPP is about software craftsmanship. Indeed, Hunt and Thomas aren't concerned about teaching you how to use a single language. Instead, they use the lessons they've learned in their combined forty years of software development experience to argue that the best programmers have a broad enough background and experience base to allow to choose good solutions in particular situations. (quote taken from the Preface, p. xviii).

In the paragraph immediately following the one containing that quote, Hunt and Thomas summarize their philosophy:

You adjust your approach to suit the current circumstances and environment. You judge the relative importance of all the factors affecting a project and use your experience to produce appropriate solutions. And you do this as your work progresses. Pragmatic Programmers get the job done and do it well.

When read completely in context, it's an extremely powerful argument. Once they're presented their goals, they get straight to work. Make sure you read the Preface.

How It's Done

In each of its eight chapters, TPP collects a series of essays covering specific aspects of software development. When reviewed as a collection, you notice that they've touched on every element of the entire development process. Coverage includes:

  • Why programmers (and their code) should be pragmatic, not perfect.
  • How to design effective subroutines, modules, algorithms, and programs,
  • Effective commenting, documentation, and communication techniques.
  • The importance of testing, as well as how to design effective tests.
  • Why version control is so important.
  • How to collect, document, and communicate the proper requirements your applications need to solve.
  • How to make users and project sponsors truly happy
  • Where to go for more information and how to ask good questions.
  • The benefits of following the book's advice as well as the dangers of ignoring it.

Take a moment to review the Chapter Summary provided below. TPP clearly covers many topics. To tie this broad range of material together, the authors' develop a series of Tips (starting in the Preface) they believe all good (read: pragmatic) programmers should follow. Not only are these Tips useful, practical, and accurate, they're also summarized in a convenient quick reference chart. Pull it out of the book and keep it near your keyboard.

You don't have to read TPP sequentially. Each essay stands on its own and is fully supported through examples, code samples, ancedotes, challenges, and exercises. Essays refer to others providing information related to, or referred by, the topic at hand. Furthermore, the book carefully refers to a wide range of other resources for continued study, including web sites, books, periodicals, and so on. TPP would make an excellent textbook for classes devoted to effective programming practices.

TPP also emphasizes the importance of personal disclipine, resposibility, and critical thinking. It effectively documents techniques ignored by most technical titles, such as othoganality, reversability, and refactoring. It provides solid advice on how to use these critical techniques, how to develop your skills, and how to prevent projects from falling apart.

Putting it into Practice

TPP was clearly designed using the techniques the author's advocate. Each word, example, description, anecdote, and point is carefully chosen. For example, the second essay in Chapter 1, Software Entropy, summarizes the findings of a study into the causes of urban decay. This study found a single trigger that rapidly transforms a building and its surrounding neighborhood into an area people avoid. (I won't tell you that cause, because I want to you to buy the book and read it for yourself. However, I can tell you from my own experience, it's accurate, easy to remember, and requires a commitment few are willing to make.)

To illustrate this trigger in action, I recently dinged another book pretty heavily for typos and other editorial mistakes understandably present in the first printing of a new book. As I said in that review, I tend to notice such mistakes. My copy of TPP is also a first printing and I found no typographic errors. While TPP's web site outlines a few syntax errors in code samples and a couple of grammatical errors, I find it interesting (and instructive) that I noticed no blatant mispellings or typographical errors. Since I know how boring, time-consuming, and exacting it can be to review galley sheets, I believe this clearly demonstrates the authors' attention to detail and commitment to quality.

Chapters move logically, carefully progressing through the same process master craftsmen use when approaching their work. It starts by analyzing thought process of a pragmatic programmer (Preface and Chapter 1), transitions to approaches that lead to excellent (read: pragmatic) programming (Chapter 2), reviews the tools you need in your arsenal (Chapter 3), and continues evolving its coverage until the final essay, Pride and Prejudice, which advises you to sign your work and to own it.

The craftmanship metaphor infuses the book. From the cover art (a wood plane), the subtitle, and the prose. Interestingly, the authors' biographies on the back cover lead with their outside interests and downplay their technical accomplishents. The author's assertion that programming is a craft is firmly delivered.

As a result, the book itself compellingly supports the practices it advocates.

Certain points may make you feel uncomfortable. That's a good thing, for it means you're aware of the authors' wisdom. Learn from your discomfort and use it to adjust your approaches accordingly. You cannot avoid previous mistakes, but you can learn from them and prevent them from recurring. The book shows you how.

Who Can Benefit?

I believe that everyone involved in any part of software development will benefit from the advice in this book, for it covers more than effective programming. Its practices apply to any project, even non-technical ones. It doesn't matter if you're a code-slinger, project manager, system administrator, support engineers, QA tester, or even a fast-food cashier. Granted, few non-technical tasks can benefit from understanding effective use of assertions, however, every task has problems to deal with and the author's ideas can be adapted to even the most obscure task. Every position requires thought and every activity flows from specific decisions that you make. This book helps you learn to make better, more effective (read: pragmatic) choices.

That said, experienced programmers will gain the most from this book, for they will have made the mistakes the authors are trying to help you avoid. Experienced programmers have seen the results the authors are trying to prevent. Experienced programmers will understand the accuracy of the authors' experiences, even if only intuitively.

For example, I recently ranted about a project I'm currently involved with. Had I employed this book's advice from the start of that project, I doubt it would be floundering now. Had I had this book's knowledge in hand ten years ago, I would not have had made certain mistakes. I can honestly say that it will improve my future efforts.

This is not to say that novice programmers can't learn from the book. The information presented is valuable to anyone in the process. However, you may not fully appreciate that until after you'd made some of your own mistakes and developed some of your own ideas from practical, real-world experience.

Again, you need this book. You need to read and re-read this book (often). You need to refer to it when you're stuck and before you write a single line of code or design a single algorithm.

Summary

It's very easy to review a bad book. You catalog a laundry list of major flaws, tell your readers to avoid the title, and then submit the copy, secure in the knowledge of a job well done.

Good books are just as difficult to review, for you want to communicate your reverence over the authors' accomplishments, your wonder at the accuracy of their observations, and your honest hopes for the book's success. Indeed, there's an awareness that your review must be as carefully crafted as the work you're reviewing, for failing to do so may allow some readers to pass on the title.

I don't want to make that mistake in this review. If you're not convinced you need this book, please look past the shortcomings of my writing skills and see my enthusiasm for the work. I realize I've been a little lean on the specifics; that's because Hunt and Thomas communicate their ideas better--and more succinctly--than I can.

If you care about your work as a programmer, wonder how to develop your programming skills, are frustrated by the lack of progress on a project, or even if you think you know it all, I strongly and emphatically implore you to buy this book. If you read it, incorporate its ideas into your work, and return to it frequently, you will become a better programmer. Yes, it'll take time, but the investment will return far more than it will cost.

Final Score: Six out of five camels...yes, it's that good.

Table of Contents

  1. A Pragmatic Philosophy
    1. The Cat Ate My Source Code
    2. Software Entropy
    3. Stone Soup and Boiled Frongs
    4. Good Enough Software
    5. Your Knowledge Portfolio
    6. Communicate!
  2. A Pragmatic Approach
    1. The Evils of Duplication
    2. Orthogonality
    3. Reversibility
    4. Tracer Bullets
    5. Prototypes and Post-It Notes
    6. Domain Languages
    7. Estimating
  3. The Basic Tools
    1. The Power of Plain Text
    2. Shell Games
    3. Power Games
    4. Source Code Control
    5. Debugging
    6. Text Manipulation
    7. Code Generators
  4. Pragmatic Paranoia
    1. Design By Contract
    2. Dead Programs Tell No Lies
    3. Assertive Programming
    4. When to use Exceptions
    5. How to Balance Resources
  5. Bend or Break
    1. Decoupling and the Law of Demeter
    2. Metaprogramming
    3. Temporal Coupling
    4. It's Just a View
    5. Blackboards
  6. While You Are Coding
    1. Programming by Coincidence
    2. Algorithm Speed
    3. Refactoring
    4. Code That's Easy to Test
    5. Evil Wizards
  7. Before the Project
    1. The Requirements Pit
    2. Solving Impossible Puzzles
    3. Not Until You're Ready
    4. The Specification Trap
    5. Circles and Arrows
  8. Pragmatic Projects
    1. Pragmatic Teams
    2. Ubiquitous Automation
    3. Ruthless Testing
    4. It's All Writing
    5. Great Expectations
    6. Pride and Prejudice

Appendices

  1. Resources
    • Professional Societies
    • Building a Library
    • Internet Resources
    • Bibliography
  2. Answers to Exercises

[- End -] 


In reply to Pragmatic Programmer, The by footpad

Title:
Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post; it's "PerlMonks-approved HTML":



  • Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
  • Read Where should I post X? if you're not absolutely sure you're posting in the right place.
  • Please read these before you post! —
  • Posts may use any of the Perl Monks Approved HTML tags:
    a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
  • Outside of code tags, you may need to use entities for some characters:
            For:     Use:
    & &amp;
    < &lt;
    > &gt;
    [ &#91;
    ] &#93;
  • Link using PerlMonks shortcuts! What shortcuts can I use for linking?
  • See Writeup Formatting Tips and other pages linked from there for more info.
  • Log In?
    Username:
    Password:

    What's my password?
    Create A New User
    Chatterbox?
    and the web crawler heard nothing...

    How do I use this? | Other CB clients
    Other Users?
    Others musing on the Monastery: (6)
    As of 2014-12-20 07:42 GMT
    Sections?
    Information?
    Find Nodes?
    Leftovers?
      Voting Booth?

      Is guessing a good strategy for surviving in the IT business?





      Results (95 votes), past polls