DEV Community

Victor Cassone
Victor Cassone

Posted on • Updated on


The foundation of self-taught development

If there’s only one thing I could teach someone before they started learning to program, I’d teach them how to be consistent.

All learning is built upon the foundation of consistency.

We are all capable of learning hard things. Successful self-taught developers don’t have any special abilities that others don’t possess.

What they do have is the habits, routines, and/or life circumstances that allow them to consistently apply effort towards learning.

I believe the hard part about learning programming isn’t the difficulty of the material but rather setting up your life in a way that allows you to consistently chip away at your goal.

Existing habits are hard to break. Expectations of the people around you are hard to manage. These factors are often overlooked.

Intelligence and natural ability aren’t the limiting factors. Anyone can learn to program if they spend enough time on it.

The key difference between someone who has successfully taught themselves programming and someone who has failed is that one person stopped before the job was done and the other person didn’t. It’s that simple.

A slow learner who shows up consistently will always outperform a fast learner who quits early.

Regardless of who you are, learning to program is a large undertaking that requires a sizeable commitment of time.

Unless we discover a way to upload memories into our brains, the only reliable way we can chip away at this large pile of hours is through consistency.

Repetition, time and effort are the only ways to signal to our brains that a skill is worth holding on to.

Short cuts and hacks don’t work. It’s not possible to become proficient at programming by drinking a case of Red Bull and studying for 3 days straight.

Just like eating an elephant, learning programming can only be done one bite at a time.

The keys to consistency

As I see it, consistency can only come from two places; habits and/or motivation.

Most of us rely on motivation anytime we start anything new. The excitement of the moment drives us to buy an online class or start on a new project.

Motivation works great for a while but it usually runs out of steam(as I’m sure we’ve all experienced).

External motivations eventually lose their power or shift away. Internal motivations are under constant assault by the fears and doubts we all carry.

We lose the fire we once had and we end up right back where we started.

Relying solely on motivation for long periods is a risky endeavor.

Yes, it’s possible to teach yourself programming through sheer willpower and motivation. As Neicheze said, “He who has a why to live can bear almost any how.”

But I wouldn’t bank on it.

Your best bet is developing a set of reliable habits and routines.

Developing habits

Luckily, there is a lot of great research and insights when it comes to developing habits. The technique I’ve found the most effective is the Tiny Habits method developed by BJ Fogg who is a professor of social science and the founder of the Behavior Design Lab at Stanford.

I’ll dive into Tiny Habits more deeply in a follow-up article. For now, I want to focus on the most important component outlined by BJ Fogg and others: starting small.

A common mistake people make when developing a new habit is starting too big. We tend to think of behavior change as one big step rather than a series of smaller steps.

The problem with big changes in behavior is that they are fragile. Changing a lot of things at once creates many points of failure.

Big changes in behavior are attractive because they feel like the most efficient route. We tell ourselves something like, “If I study for 3 hours a day then I’ll learn programming in no time.”

But the fact is big changes in behavior are much less likely to be codified into habits. Habits need time to develop and big behavior changes usually don’t stick around for very long.

If consistency is the goal then it’s important to start small.

Starting small

I like to think of starting small as the minimum viable behavior required to perform a new desired habit.

Here’s an example from my personal life.

I used to have a lot of trouble going to the gym consistently. One day I decided to change what I deemed a successful trip to the gym. I told myself all I needed to do was physically put myself inside the gym.

During my first few weeks, there were days where I would show up, sit in the locker room for a few minutes, then leave.

I didn’t care. I counted it as a win. I was happy because I was building a routine of going to the gym. The rest came later.

Apply the same logic to learning programming.

Find a specific time of day where you can sit down at your computer and do one exercise or write a few lines of code.

You can always do more if you feel like it. Just make sure you never do less.

It might feel weird at the beginning focusing on something so small. However, starting small forces you to focus on the handful of actions that are essential to the new habit. Starting small also lowers the effort required to perform the new behavior.

Don’t worry about how focused you are or about how much time you spend. You can increase the quality and quantity of your learning at a later date.

Consistently showing up creates the foundation that everything else can be built upon.

As time goes on, the new habit will get easier and you’ll be able to add more layers to your study routine.

Once you’ve successfully started small, guard your new habit with your life. If the foundation crumbles, everything else will come crashing down

Teaching yourself programming isn’t easy. Each day can be a grind. However, you don’t give yourself a chance if you don’t show up.

In part 2 of this article, we’ll dive into the various techniques you can use to develop good habits. We’ll take a deeper look at BJ Fogg’s Tiny Habits behavior change model and look at ways you can apply it to self-taught development.

Until then, best of luck.

Sign up for the Learn to Code Newsletter to receive non-technical content on how to successfully become a self-taught developer.

Top comments (0)