On teaching beginners

I was recently working on putting together some new workshops, one on Git and another on Django fundamentals. (You can see them here #shamelessPlug ). It's waaay more work than putting together workshops and content for more advanced topics.

In general, teaching advanced skills is often easier than teaching the basics. This statement might seem a little bit backwards - surely in order to teach advanced skills, one must have advanced skills?

Well, yes, clearly.

But if someone is in a position where they are receptive to learning advanced skills, then they should have some solid foundational skills in place already. And building those foundations is hard.

Here are a few things that make teaching new programmers difficult:

Missing basics and weird habits

If you are teaching someone inexperienced, then they will have a lot of unknowns that are unexpected. It's easy to make assumptions in this space. It's easy to get into "I thought everyone knew that" situations.

Some of these things are obvious and some are not. Some might even fall into the realm of computer literacy skills.

For example, if you are teaching basic development, there could be students who aren't clear on what a "text editor" is, and who don't have the skills to figure it out.

There could be students who are not comfortable in understanding directory structures because of how different GUIs display and arrange information. They might not fully grasp things that seem simple, like what is the "root directory"?

There could be students who are not familiar with common keyboard shortcuts. Or who save everything to their desktop. Or who think it's alright to hard shut down a computer in the middle of an operating system update.

Designing courses becomes difficult because trying to fill in all the possible gaps is difficult and tedious. And if you try to tick all the boxes then things can become unfocused.

As a teacher, it's important to pick your battles and be attentive:

Pick your battles

If you try to make the perfect course or write the perfect book then it's easy to get into the territory of diminishing returns.

Making sure that every concept is covered in a way that every person can understand it a BIG and never-ending job. And it actually leads to a reduction in quality a lot of the time because a lot of the content would be unnecessary and distracting for a lot of people.

So it's important to choose what basics to cover and how deeply to cover them.

For example, in the Getting Git course I recently created, it makes sense to teach people a little bit about how graphs work, without going into super deep detail on graph theory. And it's useful to teach people some Bash basics (and Bash itself is a good teacher, so this sets learners up to discover things they will need later on).

But teaching folks what a text-editor is is out of scope.

Be attentive

If you are teaching a course and you see someone getting stuck in a weird way, then be prepared to unstuck them. Instead of trying to create the perfect course that ticks all the boxes, pay attention to what people need and help them on the fly.

This is useful because it shows students how you engage with different problems.

Common misconceptions

Another challenge is that learners might have done some weird pattern matching and learned the wrong thing.

Here are a few common misconceptions I've seen in beginner programmers:

• Return and print are the same thing (this comes up a lot for languages like Python and JavaScript)
• If there is a for loop and a list/array, then we are always iterating over the array
• If we are doing anything with an n-dimensional data structure, then we need n nested loops. Eg, a 2d list always required 2 for loops

There are also about a million different ways that people get confused about the order in which lines of code execute.

These misconceptions lead to strange looking code, unproductive behaviors, and low productivity.

Just spotting these problems is a whole thing. And these problems cause people to hit very unexpected glass ceilings.

Metacognitive skills

Probably the biggest and most difficult part of teaching programming to beginner programmers is conveying the metacognitive skills and mindsets needed for success.

In fact, the way I think about teaching basic code is this: I teach basic code in order to help folks learn and practice metacognitive skills.

When teaching folks with advanced software skills, a lot of this is already in place and well-practised.

If you get people to see how useful it is to run little experiments, to see what happens, to risk being wrong - they are more likely to spot their own knowledge and skill gaps and solve their own problems

If you teach people to ask clear and well thought out questions then that acts a bit like rubber-ducking and helps them build up the ability to find solutions to problems. Make yourself easy to help and you are more likely to get the help you need.

If you teach people to always write code that makes its intentions clear, then that pays dividends forever.

Many people, in the beginning, do all sorts of weird things. Many will hit their code with a hammer and try to force it to work, sometimes by changing things almost at random, sometimes by introducing a lot of complexity.

Many folks will make guesses and then move on without checking themselves or making any effort to validate their work.

Some people will get into the habit of "I'll come back and clean that up" which leads to all sorts of issues.

To get good at this stuff, really good, it's important to cultivate a kind of mental precision and discipline.

Good teachers can help with this, but it takes quite a lot of skill.

Life and experience is also a great teacher.

Identity and struggle

The next challenge is to do with a person's self-concept and confidence.

Learning to code is hard. It's hard to get good. Experience comes from solving problems, facing and overcoming challenges.

If you put a challenge in front of an advanced developer then they are more likely to lean into it with confidence, secure in the knowledge that they have solved hard problems before.

It takes time to build that confidence.

For people who are at the beginning of their journey, challenges can seem insurmountable. For people who do not fit the stereotype of the standard coder, challenges, mistakes and knowledge gaps can be seen as proof that "I'm just not cut out for this".

When it comes to teaching beginners, a lot more care must be taken when it comes to the emotional journey of the learner. This means that the teacher has to have a fair amount of self-control and self-awareness.

I have covered some of this in a previous article. The sad fact is that a lot of high potential people quit programming because of these kinds of challenges.

Advice to beginners

If you are new to programming and reading this, I'd like to offer you some advice on how to grow your skills. It's a confusing world we live in.

The Internet is full of learning resources. It feels saturated. This is both a blessing and a curse.

A lot of people who are learning to code for the first time end up in analysis paralysis, trying to find the ultimate resource to learn from.

A lot of people end up following advice that is not appropriate for them, or just plain misguided.

A lot of people end up signing up for risky and expensive bootcamps with big promises and opaque products.

There is no one-size-fits all solution or piece of advice that I can offer you.

But here are some general recommendations.

1. If you are struggling to pick a language to start with, just go with Python. It's very beginner-friendly, very powerful and versatile, and a great teacher in itself.
2. Focus on building stuff, don't just do tutorials. Go deep and challenge yourself
3. Focus on understanding the stuff you build. Find ways to test your own understanding
4. If you go to a code-school or bootcamp, choose one that puts care and attention into the craft of teaching (like mine 😉 ). Many bootcamps hire developers and then expect greatness with low or no support
5. Find a mentor if you can