Skip to content
cropped-cropped-SeekPng.com_computer-clipart-png_1187731.png





Do Full Courses Really Help You Become a Great Coder? I Say Yes. Here Is Why.

Photo By Ian Schneider from Unsplash

Learn to learn code faster, using techniques honed by years of study, neatly packaged into one book: How to Learn Code

I absolutely LOVE monolithic courses. They offer unique benefits you cannot get from individual tutorials and, if the course quality is high, it helps deter tutorial hell.

What exactly is a monolithic course? Well, it is a series of lectures, usually with code along, quizzes, homework & projects. Well, this is the ideal monolithic course. But, it gives relatively the most complete knowledge of a topic.

To be transparent, the absolute best monolithic courses typically have you pay. Courses on Udemy are an example and often cost $13-$30 for life time access. Free monolithic courses are not as good, I hate to say it, but you can find free courses on YouTube. Channels like freeCodeCamp are chock-full of monolithic courses, some better than others.

Let me help you distinguish between a monolithic course and a series of lectures/tutorials or an individual tutorial

Table source: made in Word

The basic idea is, monolithic courses are like college classes, without the community. It has a curriculum/structure, it gives a complete/near-complete teaching on a technology and it builds on itself as you go.

The author will know 100% what it is you currently know as you go along the course. They can meticulously structure their teaching to your current knowledge base. Usually, they give a curriculum(Udemy) or a curriculum using time stamps on YouTube. 

An example, for YouTube, you click the bottom of the video:

Video by freeCodeCamp

This separates the teachings a bit and helps you see ahead to what you are learning. The course author should have meticulously put this together. In this particular video above though, it is not a good example of a monolithic course. It doesn’t have enough implementation and shifts topic too fast.

Anyway, a final selling point. The goal of the course author should be to give you the most used and important information of the technology first. It is to build knowledge on knowledge in order of how much you will use it.

The first 1/4 of a course should be able to get you up and running on projects or language exercises quickly.

How Should You Structure Your Learning?

The majority of people always learn best by implementation first. There should be a consistent ratio as to how much implementation to course time you are consuming.

It really depends on how you learn best. Also, as you progress you will learn differently. Ratios and learning styles change over time. So, here are some example ratios:

  • 1 monolithic course + 1 project in same technology
  • 1 monolithic course + some exercises/day of code
  • 1 course + 1 project + 1 session of exercise/day of code(more on this in a bit)
  • 2 courses(different technologies) + 1 project + play(Random fun tech stuff)
  • etc.

The thing about this. One structure can be good for 3 months, then another is best. Sometimes you don’t need courses and benefit from pure implementation for a limited time. Other times, you need 2 courses and 1 project. And sometimes pure play is a major benefit.

It depends on your specific needs at the time and only you can really feel what you need…

And, I don’t mean to be mystical or anything about this but, MeetUps in your specific technology tend to magically help you figure out your ratios and I am not the only one to confess this. If you feel lost about how to learn your chosen technology, one or a few MeetUps on that framework, language, etc. can hyper clarify your needs.

There is just something about being in a room or video chat of 10 people ahead of you, behind you or at your level that just magically clarifies things.

If you are unemployed or a student it is good to double up and learn two, max three unrelated technologies at once, so, max, two monolithic courses and maybe a project. 

Doubling up is great for making massive progress, but it requires the technologies you are learning to be completely unrelated. Your goal should be to learn two things as if they were two completely separate things.

Like, HTML/CSS & NodeJS, Java & Linux, C++ & Cloud or Python & containers(Docker/Kubernetes). 

This is great for making epic progress but requires discretion and project building, which is why its good when a student or unemployed. Even better, watch a monolithic course on the course you are taking in class. Ideally, (this has happened to me several times), find a monolithic course that has a near identical curriculum as your college class.

How To “Do” as a Beginner

In the beginning it is a requirement to learn just a little bit, implement it, self-discover then learn a little more. As you progress between learning, implementing and self-discovery you will find your ability to learn theoretical knowledge grows.

Your background allows you to pick things up with less implementation. The basic idea is a balance between theory & implementation. You will find having a high cognitive faculty (which is trained by coding) decreases the amount implementation you need for the theory you are learning.

So, what should you do?

Well, what you have here is a learning curve. And, look, I will be real with you. If you are like the grand majority of us, 90% of us, including me, you will need a LOT of implementation.

Yes, there are people who will wizz through things like its nothing. And there are multiple factors to this. Two of which is one, natural cognitive ability, and two, how much importance/desire they put into learning(like time, effort and love).

What is really great about these factors is, they are trainable. You can learn to love any technology & your cognitive abilities will most definitely improve as you become a better coder. So I tell you, do by doing.

A few years back there was a popular programming meme where a programmer asked “how do I get good at programming?” A chad programmer goes up to him and puts the mouse in his hand and points at the screen. That is how it is done.

Image Drawn by Sara Andersen

Okay, so what exactly do we implement? As a beginner it is difficult to choose what to do. Here are two things which would replace your project in your language/technology.

Do exercise workbooks

Perhaps the first thing I would do, is a programming exercise workbook during my monolithic course. The basic idea is to learn many concepts by completing exercises and making them as cool as possible.

Back when I first started programming, within the first 3 months, I did this. I completed ~ 120 Java exercises which got progressively harder. I still have them on my Cloud storage today (which I look at with pride).

I always meant to create a GUI which populated a list of buttons of these Java files and ran them, exiting upon clicking. Then, when the exercise opened I would complete the function and have an exit input which would lead back to the GUI.

Hey, it is a cool idea. I just had my college classes taking up too much time at that moment. Anyway, I recommend these exercises and saving everything, I think it is nice to have them to look back to. 

Here is an example list: Java exercises for beginners

Background by Pankaj Patel on Unsplash

Do 100 days of code

This is essentially the same thing, but for more advanced coders. A 100 days of code challenge is to complete a series of projects in 100 days, 1 per day. 

Now, most people often split one day into two or three when it is particularly hard. But the idea is to do this at the same time as your monolithic course. 

Do a project in your technology

Find project idea lists for beginners, intermediate & advanced. Complete one at a time, make them your own, then keep them on GitHub. Try to squeeze as much learning as you can out of them.

If they are particularly useful they can serve as example code in the future. In addition you can maintain them or rewrite them.

What To Do if You Can’t Find a Monolithic Course for Your Topic

The best thing to do in this case, is to stick to the monolithic model, with the best you have. I will give you a prime example of a technology that literally has no monolithic courses and what to do about it. It is graphics programming.

Graphics programming, for some odd reason, has few truly monolithic courses. It requires so much background and has an infinite upper bound of skill.

You can go from peasant to literal god in this field after many years of implementation and reading and you would have to do it with near zero monolithic courses.

How is this done? Implementation first. You are basically back in the good old 80s & 90s here. They did not have YouTube or Udemy or Coursera or Plural Sight. 

This is the wild wild west. We are back in ye old where you simply need to do.

But, at the same time, it is good to find the resources which lend itself to being the most monolithic available for that topic. Spoiler alert, the most monolithic resources I could find for OpenGL are learnopengl.com, opengl specification, shader specification, real-time rendering and that does not include the math!

Even in the wild wild west, you hear stories of John Carmack, the creator of Doom, used monolithic textbooks to learn memory manipulation in graphics programming, back in the primitive days.

Why You Need To Make a Reference Manual

I was going to put this in additional tips. But, this piece of advice is so good, it deserves its own heading. If I were you I would make it a requirement. The idea is to write down and organize what you learn in a way that you can refer to it later.

Here, you want to focus on terminology & concepts. The key essential stuff should be emphasized and it should be ordered and worded carefully, tailored to your future self.

The goal is to keep your current understanding in your monolithic course through your reference manual.

As you create these manuals you should get better at teaching your future self and you will find these invaluable.

For the note-taking app I recommend Codex.

Additional Tips

Here are some pitfalls and tips which you should avoid or do…

Learn Do Learn Do Talk/Teach/Tutor

LDLDT. Learn it, implement it, learn more, implement more then talk/tutor/teach. This is a great order of solidifying what you gaining from a course. It is particularly good to talk to knowledgeable peers about a topic you are both interested in, then tutor someone who wants to learn what you know.

Spaced repetition

It is good to learn slowly. Perhaps dedicate one or two 40 minute sessions to your monolithic course per day and 2 hours (more implementation is a good thing)of project/exercise making. The idea is to do this every day over a long term to completely solidify the knowledge.

Think of this like brick laying a wall, you want to stop and let the brick cement dry before you add more bricks.

Collect 2 or 3 monolithic courses per technology, review weak sections later

Having 2 or 3 courses on a technology is great for review. I would keep an excel sheet or Codex section/table about all the courses and resources you would use or have used for a tech.

Later on, when you want to fill programming gaps, you can review with your old course sections on those topics.

Signs of a bad course

There is such a thing as a bad course. There isn’t much to say about these signs. Just be aware of them and choose courses based on what you can stomach and go through them as thoroughly as possible. Just find the best you can out there.

Here are some signs:

  • It doesn’t have enough implementation
  • It skims topics too quickly
  • The author has a bad accent
  • There is no structure
  • There isn’t enough content

Well thank you for reading, I hope you learned something.

Happy Coding!

Resources

What is tutorial hell: https://www.linkedin.com/pulse/how-escape-tutorial-hell-ikechukwu-vincent/

Meetup: https://www.meetup.com/

freeCodeCamp.org: https://www.freecodecamp.org/

Java programming exercise list: https://pythonistaplanet.com/java-programming-exercises-with-solutions/

learnopengl.com: https://learnopengl.com/

OpenGL 4.6 specification: https://registry.khronos.org/OpenGL/specs/gl/glspec46.core.pdf

OpenGL shader specification: https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf

Real-Time Rendering book: https://a.co/d/eW6pKBD

John Carmack: https://en.wikipedia.org/wiki/John_Carmack

John Carmack video: https://youtu.be/HOv_dWDgIRM?si=bvf10VA-uO1n_axJ&t=251

Codex: https://codexnotes.com/

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts

Learn to learn code faster, using techniques honed by years of study, neatly packaged into one book: How to Learn Code