An Approach to Learning Coding for Absolute Beginners

Introduction

Are you an absolute beginner struggling to learn how to code? Have you consumed lots of tutorials, bought different courses, paid for an expensive coding bootcamp but you still don't get it?

Do you complete a course where you coded along and built the demo project, but when it comes to building something on your own, you get stuck?

OR

Have you followed the ever-popular advice of "Find a Project you Love and Just Build It" with the belief that you'll learn as you code up that project? But you get overwhelmed with the amount of things you need to learn. Then you just give up and say "coding is not for me."

Learning to code this way has some downsides and in this article, we'll go over a beginner-friendly approach to learning programming.

Video Version

Here's the video version if you prefer videos:

Disclaimer

Firstly, I must start by saying: "Programming is hard" and this is not an article that tries to sell you a course on how to easily become a top coder.

That's a fantasy.

However, the approach I cover in this article is going to help you become efficient and make progress in your learning journey.

Common Approaches and their Downsides

Let me share with you the downsides of consuming lots of tutorials OR by using the "just build stuffs" approach to learning programming.

Common Approach 1 - Consuming lots of tutorials

Coding courses and tutorials are great. You read articles, watch YouTube videos and buy all the courses that constitute some learning path.

You watch them all to the end. You have cool sample projects. But guess what...you did not really create them. You coded along and built something cool. Congrats!!!

But that's not your work. And how do I know?
Simple, try rebuilding any of the project from scratch to test your knowledge.
You'll see that you'll struggle to build anything close.
You'll even struggle at the most basic feature. But remember, when you were following the course, you believed you understood the code.
That's not how learning works.

Following along does not really solidify the neural patterns for that concept in your brain. You need to build and repeat over a period of time to make the concept stick.

1. So, the first downside is the inability to build something by yourself. You spent so much time consuming and not building something soon enough on your own to test your knowledge.
2. The second downside to this approach is that, it's going to be hard to gain confidence in your programming knowledge because you'll always feel there's still more to learn and you'll keep consuming more tutorials to fill in the never-ending knowledge gap.

This is commonly known as "Tutorial Purgatory."

"Tutorial Purgatory" simply means consuming so much tutorials and never feeling you have learnt enough to build stuffs.

And believe me, you can never satisfy this urge if you continue like this because we have millions of tutorials all thanks to the internet.

Common Approach 2 - "Just Build Stuffs"

The second mistake is to "Just Find a Project You're Passionate About and Build It" OR "Build then Learn on the Process."

This seems reasonable but How do you "Just Build Stuffs" when you don't even know the basics and the complexity of that passion project you have in mind?

You need to watch tutorials OR buy courses, right?

Well, the problem lies in "How you use those tutorials." Its just like saying medicines can be good and bad...It all depends on how you use them. An overdose would be a bad way to use it. You get the idea.

Now, the problem with this advice is that:

1. this is mostly coming from experienced programmers or people with some technical background. For example, someone with a background in telecommunication engineering could transition into software engineering with this approach thanks to their engineering background.
2. Also, you need to know the basics in order to be able to "Just Build Stuffs." For example, Someone with a C++ background could transition into Web Development by just diving in and build stuffs then learn along the way. This was how I learned Kotlin and Native Android Development and this was possible because of my background knowledge as a decent Programmer.

You can see the emphasis here is knowing the basics before building stuffs. And don't get me wrong, some people have learned to code by diving in and just building stuffs. It's very possible, but we're looking for an approach with a higher success rate.

Now you might ask: "If watching tutorials and just building stuffs are not the way to go, then what's the way?"

Its actually a combination of the two.

Throwaway Apps

Back in 2017, I came across an article by Dave Ceddia where he laid down a timeline for learning React.
In there, he introduced a concept called "Throwaway Apps." These were small apps that you build after learning a concept or finishing a module in a course. You build them then throw them away. Its that simple. And throwing them away here simply means that these apps were not portfolio worthy because they were small and focused on a concept that was just learned.

With this approach:

• You eliminate the Dunning-Kruger effect which is an illusion of competence whereby you have a false belief that you're confident you understand a concept for example after completing a course. You don't have to wait till you finish the course to build something on your own. With this, you can be able to spot knowledge gaps early enough and go back to the learning material to cover them up.
• also, since the throwaway apps you build are small, you can see results and observe your progress. And according various research, only about 5-15% of people who take online courses completes them. So the earlier you build something after learning a concept, the better it is to keep you motivated.

Now, this is not me trying to say that this approach is the best. I just want to let you know that whatever I share here is from a place of research, trial, error and experience.

I've created tons of courses, taught hundreds of students in person and developed learning curriculum for close to 10 years.
In this journey I've had to learn, unlearn and relearn new methods for learning and teaching programming effectively.
Over the years, I've seen what works and what doesn't.

Throwaway Apps How to 1: for Bootcamps

I've used these approaches to teach my bootcamp students and the first cohort I tried this on recorded one of the highest employment rate after the bootcamp. Basically, after we learn a concept, I give them a throwaway app to build and I watch them sweat.
We do this regularly after we cover important sections in the curriculum.

When they feel they're comfortable with something, I surprise them with a throwaway app from some concept they've learned some weeks ago. Most of the times, they do well because I teach them to always practice concepts at intervals in order to solidify the learned concepts.

This is known as "Spaced Repetition" i.e repeating some action or task after some given time in order to test if you remember the concept which in turn strengthens the neural network for that knowledge in our brains.

They learn first before they build stuffs and not the other way round of just "building stuffs then learn while building it."

The approach of learning while building is for people with some technical background that have some basics already covered.

Let me show you how to apply the Throwaway app approach with any learning material.

Throwaway Apps How To 2: Courses & Books

Let's say you want learn full stack web development with JavaScript.

Here's a sample curriculum:

Now you might think that your first throwaway app should come after you're done learning HTML & CSS.
If the course curriculum is well structured then that's already too late and lots of concepts would have been covered.

I teach using the process of chunking which I learned from Professor Barbara Oakley, a renowned Engineering Professor who is also an amazing teacher.

Chunking simply means breaking down information into smaller manageable parts.

Let's break down the HTML & CSS module into a sample curriculum:

You can see it consists of different parts that makes up the HTML & CSS module. A good place to build a throwaway app would be after the "Links and Pages" part.

Building a throwaway app after this shows that you understand how to structure a basic webpage and how to add links. You could build a simple restaurant app with pictures of the restaurant, the menu of the day and also an about page then link to it.

The next throwaway app could come after the "CSS Pseudo Selectors" part.

You could revisit the restaurant app and style it with CSS but I'll suggest you code up another throwaway app with HTML and style it with CSS.

With this, you've used the power of repetition which strengthens the neural network that was built in your brain while working with HTML. And you're also taking it up a notch by creating a new neural network in your brain for the CSS knowledge. Then you can keep applying this as you move on.

Some great courses have good practice exercises. But remember, when using the throwaway app approach, you're stepping outside the course to practice on your own. If you get stuck, you can revisit the course content to get clarity.

Do note that I strongly suggest that throwaway apps should contain only concepts the learning materials have covered. You shouldn't be building something outside the knowledge of what you've learned. Remember, you want to strengthen the knowledge in your brain.

As an absolute beginner, you shouldn't be too ambitious with what you build. Learning is a journey, so be patient. You'll be able to build really cool stuffs with time.

Also, completing the course might take up more time but you'll be sure you're understanding and becoming confident in each concept as you move forward.

Conclusion/Summary

So that's throwaway apps in a nutshell.

• you learn in small chunks
• you build throwaway apps after learning a concept in order to test and solidify your knowledge
• you learn then build and not the other way round of finding a project to build then learning in the process, that's for people with some background knowledge
• and finally, learning the basics of any concept is super important. Never skip the core fundamentals, else, you'll struggle in the future.

No need to rush. Learning programming is more like a marathon than a sprint. It takes some time to build up your skills.

This is my recommendation for learning programming for absolute beginners. This can be used with any tutorial, course, bootcamp or learning path. This is not an alternative form of learning. Instead it can be integrated into whatever learning material you're using.

Once you've built various throwaway apps, you'll get to the point where they become easy and this can get boring over time. This means you're ready for the next step of your learning journey.

In the follow up article, you'll learn how to level up your coding knowledge. This is for those that have covered the basics and want to build something bigger than a throwaway app.

Happy learning and I'll see you in the next one.