Monthly Archives: February 2014

The Pragmatic Programmer – My Review

The Pragmatic ProgrammerI started reading The Pragmatic Programmer three weeks ago. It was a gift I received on the occasion of my 28th birthday! And now that I just finished the book, I decided to write this review to share my thoughts on all what grabbed my attention while reading it.

As a long-time programmer and architect, I was always thinking that being pragmatic isn’t only a matter of mastering technologies but also and more importantly a matter of wisdom and maturity. I would define pragmatic programmers as those who developed the ability to keep in mind the big picture of a given project when diving into every aspect of it. This paradigm isn’t taught at schools and universities.

This book teaches you how to adopt the right mindset when addressing certain classes of problems. It shows pragmatic techniques that help you become a better programmer. Each aspect is illustrated through relevant analogies (as the helicopter example to explain orthogonality) and summarized into a collection of inspiring tips. I selected some of them,

  • Care About Your Craft
  • Provide Options, Don’t Make Lame Excuses
  • Be a Catalyst for Change
  • Design with Contracts
  • Abstractions Live Longer than Details
  • Don’t Assume It—Prove It
  • Organize around functionalities, not job functions
  • Always Design for Concurrency
  • Don’t Think Outside the Box—Find the Box
  • Don’t Live with Broken Windows
  • Remember the Big Picture
  • It’s Both What You Say and the Way You Say It
  • Don’t Be a Slave to Formal Methods
  • Organize Teams Around Functionality
  • … and so on

Andrew and David provide a set of practical advices based on their many years of experience adapting and integrating a large variety of techniques and tools to improve their processes. These advices are addressed to both beginners and experts, even if you just started coding, grab a copy of this book, you may probably don’t understand all the concepts but there will be enough to learn for you.

Also, many explanations in this book are  language-independent, which is really nice.

You’ll probably find many reviews on the web,  but I would like to quote Kent Beck, author of Extreme Programming Explained: Embrace Change, who says:

“The cool thing about this book is that it’s great for keeping the programming process fresh. The book helps you to continue to grow and clearly comes from people who have been there.

I would also refer to John Lakos’s (Author of Large Scale C++ Software Design) point of view,

“The wisdom and practical experience of the authors is obvious. The topics presented are relevant and useful…By far its greatest strength for me has been the outstanding analogies–tracer bullets, broken windows, and the fabulous helicopter-based explanation of the need for orthogonality, especially in a crisis situation. I have little doubt that this book will eventually become an excellent source of useful information for journeymen programmers and expert mentors alike.”

If I had to summarize my impressions after reading this book, I would join Kent & Lakos on their thoughts.