I started reading a book by Andy Hunt, Pragmatic Thinking and Learning, refactoring your wetware.
In the Dreyfus model which studies the five stages in the journey to from novice to expert , Herbert Dreyfus states “to become competent, you must feel bad.”
- Advanced Beginner
Stage 1: Novices
Novices are primarily concerned about their ability to succeed. As they don’t have enough experience to guide them they are unsure if their actions will lead to a successful outcome. Novices may not be primarily interested in learning as they are as in accomplishing a goal. Unsure of how to respond to mistakes or obstacles, they are vulnerable to confusion and frustration when things go awry.
Novices, by definition, have little or no previous experience in this skill area. Experience is acquired by performing a skill that results in a change of thinking.
I spent 20 years working in an IBM mainframe environment, developing and managing software applications in COBOL. I count that as 20 years of experience and the author asks the question as to was that truly 20 years of experience or something I repeated 20 times.
Novices can be effective when given context free rules to follow. When “X” happens, do “Y”, in other words they need a recipe they can follow.
Stage 2: Advanced Beginners
An advanced beginner can break away from the recipe book a little bit. They might be able to do some tasks on their own, but still have difficulties trouble shooting. An advanced beginner can start applying advice using the correct context based on their prior experience, but just barely.
At this point they are not interested in the big picture and will most likely dismiss the larger context as irrelevant to the task at hand.
Stage 3: Competent
As this point the developer can troubleshoot on their own and show the ability to solve problems that they have not seen before.
Developers at this level tend to be in leadership roles either formally or informally. They are valuable assets to the team as they can mentor the novices and don’t annoy the senior members too much.
Stage 4: Proficient
Proficient developers have the ability to self correct. They want the big picture.
Stage 5: Expert
Experts work from intuition not reason.
They are the primary sources of knowledge. These are the people who write books, write articles, speak at conferences. They are the modern day Wizards.
The expert knows which details to focus on and which details can be ignored.
Now, how are the Dreyfus lessons applied at work?
In the software development field they tend to applied poorly.
When the Dreyfus lessons are not applied properly it is easy to derail the experts and ruin their performance. All you have to do is to make them follow the rules.
In any software development methodology or culture that dictates iron clad rules, the impact on the experts is to degrade their performance to the level of the novice. All of the competitive advantage of their expertise is lost. The software industry as a whole ends up ruining experts all the time in as they attempt to herd the racehorses(the experts).
That’s not how you get a good return on your investment on a racehorse. You need to let them run, like a thoroughbred.
On the flip side, many of the novice programmers are thrown into the deep end of the pool, far over their heads in an attempt to get them “up to speed.”
So we attempt to race the sheep when they need to be herded, given clear direction so they can have quick successes.
- Always consider the context.
- Use rules for novices, intuition for experts.
- Know what you don’t know.
- Learn by watching and imitating.
- Keep practicing in order to remain an expert.
- Avoid formal methods if you need creativity, intuition or inventiveness
- Learn the skill of learning.
How have you seen the Dreyfus lessons applied during your software career?