Andy Hunt’s Pragmatic Thinking and Learning: Refactor Your Wetware (Pragmatic Press; 2008) teaches programmers how to master a subject, strategies for using your brain to its fullest, systems for learning, and the best ways to practice. The result is a grab-bag of pop-psych systems, practical strategies, and good old-fashioned inspiration that will give most programmers more footholds as they climb the tree of knowledge. I had expected the book to be about thinking more than learning (it’s not) and to be a more rigorous in separating scientifically tested theories from speculation, but despite these disappointments I still recommend the book to any programmer who wants to become better. The book is still in beta, so the final version may yet address my concerns.
The book begins with an explanation of the Dreyfus Model of Skills Acquisition, which identifies and describes five stages we pass through as we master a skill. We begin as novices, who lack a conceptual model of the problem space and also lack the basic skills. Consequently, novices need recipes or rules that specify “if X then Y” in great detail. We then moved to “advanced beginners”, who can try tasks on their own but still need help troubleshooting. They’re starting to formulate principles, and can reuse techniques in similar contexts (if only just) but still don’t have the Big Picture. Then we become “competent”, when we can troubleshoot problems and solve new ones. After that comes “proficient”, when we seek out the Big Picture and, most significantly, are able to correct our previously poor performance—we can look back at what we did and revise our approach. Finally, we become “expert” with the world view and skills so ingrained that we have phenomenal instincts that let us zen in on the answer immediately without higher-level analysis.
The Dreyfus model isn’t a “scientific truth”, it’s a philosopher’s construction that has some traction in the AI world and a lot of traction in the nursing world. Indeed, this is one of the places where I feel the book presents something that’s useful without acknowledging that it’s not necessarily an absolute truth. However, the general point is that once we have a map, however grainy, we can find where we are and the map will show us what we must do to make progress.
The rest of the book is concepts and skills for moving towards mastery. First Andy tells us the left brain-right brain story (left brain linear and rational, right brain random access and kludgy) and gives advice for engaging the correct side of the brain when you need them. This is where things start to get a bit weird. Andy talks about “free form journaling”, “morning pages”, and advice to park on the other side of the road. It’s here that I feel he’s furtherest from useful programming-related ground, although he does attempt to intersperse this rather woo-woo advice with thoughts on pair programming and typesetting code.
Then comes a quick romp through the ways in which we fail to think accurately, a chapter cleverly titled “Debug Your Mind”. He covers the standard fare of behavioural economics: fundamental attribution error, anchoring, the imbalance between gaining and losing, our nonlinear sense of risk vs reward. This is the stuff I like (and have read way too many books on lately) but it’s coupled with a discussion of demographics and archetypes of which I was, frankly, very suspicious. Sentences like “I am among the eldest of Generation X, on the cusp of the Boomers, I tend to identify with the Gen-X characteristics, especially survivalism, pragmatism, and realism” sound awfully close to a cold reading. And don’t even get me started on the Myers-Briggs test that comes next ….
In Chapter 6 we’re back onto more solid ground, learning how to learn. Some of this was familiar to me from my highschool days when I read everything I could on how to study (amusingly, this was a procrastination technique so I wouldn’t have to study). Andy talks about setting SMART objectives (Specific Measurable Achievable Relevant Time-boxed), and treating your education like an investment plan by making regular active contributions to a diverse portfolio of skills. Then we’re into specific learning techniques like SQ3R, spacing retrieval, mind maps, and (my favourite) learning by teaching. I’ve been working hard lately on purposeful reading as I habitually skim, and I found this whole chapter useful.
The final chapter in the draft I read was “Gain Experience”. This is about purposeful exercise of skills. Andy wants us to choose projects that keep our interest but also productively extend our skill set. This means dealing with failure, and Andy has a great line here: “it’s not important to get it right the ﬁrst time, it’s important to get it right the last time”. He talks about unit testing and version control in the context of purposeful play: we should have the freedom to experiment but without losing the ability to backtrack to a stable state, and the ability to demonstrate progress. He’s better here at bringing the pedagogy back to the real world of a programmer, moving seamlessly from the Inner Game of offline practising to a discussion of scaffolding and the benefits of C++ and Ruby programmers learning each others’ languages.
Andy’s thesis is that we can master a subject faster if we know how to get better at it rather than taking random walks through the manual and problem space. He does a good job of laying out useful techniques and concepts—perhaps too good. While he industriously attempts to connect the abstract theories to the concrete life of a programmer, this reviewer was left with the feeling of too much theory and too many techniques too choose from. Despite this, the book still remains a rewarding read and the only book that tackles these subjects from a programmer’s point of view. Recommended.