Hey everyone! First post on dev.to, even though I've been lurking and sharing stuff from here foreverrrr. I've told Ben for two years now that I'll post something when I see him at Codeland. But better late than never!

So, I want to let you guys in on some really critical skills I picked up early on in my self-teaching. I'll go through them one by one over time, but in this post, I want to highlight one that literally changed the way I learned.

A lot of us learn via videos, books, podcasts, blog posts. But what do we do with that information after we encounter it?

Using what we learn is both a skill AND a habit that we can build. If you don't build that habit early, you'll start spinning your wheels like I did. People kept asking what I was "working on", and I thought they meant what videos I had watched, or what lessons I had finished on Treehouse.

And yes, you can tell them you're watching videos and working through freeCodeCamp, which is a perfectly acceptable response. But what they're really looking for is to find out how you're applying the skills you're learning.

Adding to my anxiety while I was learning was the feeling that I was never quite "doing enough", or at least not The Right Thing™️. And maybe I wasn't, but I never quite gave myself a chance because I wasn't actively, regularly making a point to apply what I was learning—in the form of projects... or, more importantly, "deliberate practice".

Characteristics of deliberate practice

So, what the heck is deliberate practice?

I mean, you just sitting down practicing is deliberate, right? You made the deliberate choice to sit down and practice.

Well, that's a part of it, but deliberate practice has some set characteristics.
Deliberate practice, generally speaking, is like regular practice, but with a specific goal of improvement.

When you do something with a specific goal, it makes sense that your approach would change.

If you want to prepare for a marathon, you'll train and practice differently than you would if you were training for a 100m dash. Similarly, if you're practicing with a goal of learning JavaScript in order to be a front-end developer, you'll need to focus in solely on JavaScript, and break your goals down even further than that.

Also, working on anything that isn't a particular area of JavaScript that you need more comfort with is a waste of your time. Perhaps not a complete waste of your time, as it would be to study Spanish instead of FE dev. But still a waste, nonetheless. You'll never reach your goals that way.

Deliberate practice also requires focus and attention, as well as sustained effort and energy. Focus... attention... energy... these are all limited resources that we possess as human beings. (Buuuuut I really can't think of a better way to use your energy than on improving yourself, right?)

Deliberate practice favors quality over quantity

First, deliberate practice focuses on the quality of the practice, not the quantity.

If you look at most resources and writings out there about practice, they encourage consistency—showing up every day, ready to learn. Showing up is indeed half the battle. And you can't get better without practicing the information you encounter, which is why you stress when the training wheels are taken off.

But just showing up and doing "some stuff to get better at coding" isn't going to cut it, because it isn't sustainable.

I've been hearing the "10,000 hours" quote popularized by Malcolm Gladwell for years now, and I honestly think it's a load of crap. What happens when you practice for 10,000 hours?

What if you focus on the wrong things, or find that you still can't recall related or prerequisite information between sessions? 10,000 hours of unfocused work is meaningless, which is why I also have strong feelings about established industry folks touting their years of programming experience.

Often, they're looking things basic things up and referencing them as often as newbies are, because they never took the time to really master their work.

Mastery is rare, folks. It's not as common as we're led to think it is, since a lot of the noise comes from the folks who claim to know what they're doing.
Just remember that low-quality practice sessions are poorly structured, and lack clear goals or desired outcomes.

High-quality practice sessions, on the other hand, have a greater chance of the student emerging with understanding that sticks.

Deliberate practice is highly structured

You can't just kind of wander into a practice session with a loose goal to get better.

Get better at what?
How much better?

Once you get to that goal, what's your next small step to reaching the bigger goal?

Without structure, you're not likely to stick with it, either.

Deliberate practice gives immediate feedback on your progress

Fortunately, for web development, errors serve as excellent learning tools.
Also, a lot of e-learning platforms like Treehouse and freeCodeCamp that integrate practice on their sites with test-driven development environments provide instant feedback to satisfy this criteria.

But even with feedback like errors and TDD, there are other considerations. Is that everything involved in meeting your goal of being a really good developer in this particular area?

What about things like technique, style, and approach to problem-solving? We still mostly need humans for that, since it's humans and not machines that ultimately use our code.

We also need that feedback to be super-informative, with specific information regarding how and why you were right or wrong, and guidance to learn more as needed.

So, human and computer feedback is a critical part of deliberate practice as we're learning to code.

Deliberate practice requires repetition

The best practice involves doing the same task or related tasks repeatedly. Practice is not watching videos or reading tutorials. Those are learning activities.

And even simply repeating the same actions over and over won't produce improvement.
Think of it this way: if you show up to deliberately practice a specific action like writing a function from scratch, because you're not comfortable doing it on your own yet, you'd set up multiple challenges to write a function from scratch.

If you know your weak area is writing functions, but you decide to write things that aren't functions... you're not practicing deliberately, because deliberate practice requires exposing yourself to the same challenges, in order to bring you comfort and familiarity with solving them.

A lot of new developers think that all expert developers program from what's commonly called a "flow state". They think the developer just naturally knows how to overcome obstacles. In reality, they practiced that task frequently enough that they recognize all the obstacles on their path to their goal.

And, deliberate practice can lead to more relaxed, natural programming and problem-solving ability.

But you cannot achieve expertise without deliberate practice. It's just not possible. You'll sustain in mediocrity, at best. And that's ok for a lot of folks, but I want to help people become the best developers they can be, so if I have anything to say about it—you're adding deliberate practice to your toolbox today!

To recap:

Deliberate practice is different than what's commonly referred to as "practice", because it focuses on the quality of the practice over the quantity.

In order for practice to be deliberate, it also needs to be highly structured, provide detailed feedback and guidance for improvement, and involve completing the same or similar tasks repeatedly.

That's it! Now you know that there's basically a practice++ available for you to take your learning to the next level.

Learn more helpful skills like this! 😊

If you'd like to learn more about learning, as well as other often-overlooked but critical skills in tech, join the Life in Code newsletter! ❤️