How does a programmer employ deliberate practice?

Question

How does a career developer sharpen and expand their skill set to reach the level of expert at their craft.

A lot of scientific evidence points at the fact that experts become experts through many hours of deliberate practice.

When we look at any kind of cognitively complex field — for example, playing chess, writing fiction or being a neurosurgeon — we find that you are unlikely to master it unless you have practiced for 10,000 hours. That’s 20 hours a week for 10 years.

Deliberate practice is not just working at your job though. It is spending lot of time doing things that stretch and sharpen your skills to an expert level.

1. It’s designed to improve performance. “The essence of deliberate practice is continually stretching an individual just beyond his or her current abilities. That may sound obvious, but most of us don’t do it in the activities we think of as practice.”
2. It’s repeated a lot. “High repetition is the most important difference between deliberate practice of a task and performing the task for real, when it counts.”
3. Feedback on results is continuously available. “You may think that your rehearsal of a job interview was flawless, but your opinion isn’t what counts.”
4. It’s highly demanding mentally. “Deliberate practice is above all an effort of focus and concentration. That is what makes it ‘deliberate,’ as distinct from the mindless playing of scales or hitting of tennis balls that most people engage in.”
5. It’s hard. “Doing things we know how to do well is enjoyable, and that’s exactly the opposite of what deliberate practice demands.”
6. It requires (good) goals. “The best performers set goals that are not about the outcome but rather about the process of reaching the outcome.”

Source

Some ideas:

• employing stretching goals
• practicing code katas
• taking part in programming contests on regular basis
• learning a new technology or new languages every month/year and using it in a non-trivial way
• Reading the various bibles and finding way to apply lessons from them to a project

What do you think is the best way for a programmer to employ deliberate practice to become and expert?

Information on subject:

Original paper

Talent is overrated

Answer 1

I think there are several things you can do:

• Help solve other real-world problems via Stack Overflow and programming forum sites
• Have a personal software project that you work on at home.
• More formal "practice" in the form of code katas or Project Euler problems
• Contribute to an open source project

All of these are things you can choose to devote time to outside of work, and all of them can count for practice as described in your question if done in a way that pushes your current level of expertise.

Other things like reading code, books, watching training videos, and joining a programming user group can also help you expand and improve, but don't fall under your "deliberate practice" category as well.

Answer 2

Here's some more:

• Get involved with a local programmers group.
• Learn different types of languages like a ML, Haskell, Scala, Clojure, or Prolog.
• Attend programming/hacker conferences
• Write a blog
• Read blogs to keep abreast of new or upcoming ideas

Answer 3

The answer exists only in Tao:

http://www.canonical.org/~kragen/tao-of-programming.html

Answer 4

I've come up with an interesting answer that highlights how deliberate practice is different from say reading a blog or puttering around with some new technology.

• Take a piece of really well written code in area that you want to improve your skills at
• Read and understand the code thoroughly
• takes some notes on how it works, its general structure
• Let some time pass
• Re-write the code from scratch using only your notes
• Compare to the original and see where your code is lacking and possibly where your code is better

Repeat this again and again re-writing code from scratch without examining previous results until completion. Vary the rewrites by using a different language or framework or incorporating a different technique. For example develop with test driven development and then model driven deployment and then do it all in notepad then with an ORM and then in a functional language. Every time compare back to other versions to note how these decisions and your accumulated learning have affected the end product.

To do this properly, you will need to start with a project that is small yet complex enough to challenge your skills.

This idea is adapted from the book "Talent is overrated" but is specifically adapted from the practice of Benjamin Franklin.

To improve his writing skills Franklin used a book of essays he admired and rewrote them over and over again comparing back to the original and modifying the form as he went.

He started by taking one of the essays and jotting down a note for each sentence indicating the sentiment it contained. He then put his notes aside for a few days and then by using his notes recreated the essay in his own words. Then he compared his version to the original and made corrections. Essay by essay he could see his approach improving his skills and in some small ways he felt his expression might even be better than the original. These glimmers of erudition gave him hope.

Despite the progress Ben felt he needed more. He wanted to expand his vocabulary. What better way then than to rewrite an essay's prose in verse. Again he would start with notes expressing the sentiment of each sentence but this time he wrote his version in verse. It forced him to add variety and creativity. After a few days he'd forget the original prose and so would then take his verse and use it to rewrite the essay. Again he made a comparison, made corrections and learned by doing.