Escaping from Tutorial Hell

Image for post
Image for post
Photo by Arisa Chattasa on Unsplash

In the programming communities I’m a part of, one of the most common questions often asked is:

What are some resources or tutorials to learn [insert tool/framework/library/language]?

This is a great question for anyone that doesn’t know where to start. Just like going for a run, cleaning the dishes, or hitting the gym, sometimes the hardest part is getting started.

After pointing them to resources and hearing their progress, I start to see the cogs turning which inevitably leads to more tools to be learned and knowledge to be consumed. Excellent! All is going well. Someone driven and committed to learning about coding is starting to get into the everyday flow of discovering, learning, building, and delivering. Great!

Some people do fine with just this bit of guidance, but a trend I’m noticing that I can no longer ignore is:

I need a tutorial to build this! Where can I find a tutorial to build this?

These particular developers have unfortunately fallen into a trap, which is dependency and expectation that there’s a tutorial for everything. This trap is tutorial hell.

Tutorial hell typically comes around the time where one “sort of” knows how to build some simple things, but nothing really complex or scalable. They know some basic tools and skills, but they still want that hand holding and security blanket given from online guides and tutorials.

It’s wonderfully convenient with the power of search engines that so many tutorials and guides are just a couple of keystrokes away, but some libraries and tools just don’t have tutorials, or even worse, their un-official tutorials are terrible, and don’t follow best practices while sometimes encouraging bad habits.

While the curiosity is high and the desire for knowledge lives on, these guides and tutorials will only let someone learn through the perspective of the author, thus leading to a less intimate relationship with the subject material. They’re going to get this knowledge purely from the guide’s author or writer, not their own firsthand experience.

Would you rather look at pictures and videos of the Great Pyramids in Egypt? Or would you rather be in Egypt looking at the Pyramids with your own eyes? Through photos and videos, you see the wonders of the world from only the photographer’s perspective, not your own.

There’s a way to getting out of tutorial hell, and it’s not by doing a tutorial. It’s something that every developer has to learn in their career if they want to get out of tutorial hell — breaking down big tasks into smaller ones.

Deconstructing a Tutorial

Rome wasn’t built in a day, and neither will a large scale development project.

What tutorials do very well for newer developers is they break down a project into steps:

A good tutorial resource will never just list one giant thing to do:

HOW TO BUILD A TO-DO APP
STEP 1: BUILD A TO-DO APP.

A good tutorial resource will often break things down into small, digestible chunks for you to consume and learn from slowly:

HOW TO BUILD A TO-DO APP
STEP 1: Make sure you have prerequisites installed on your computer, like Node.js, MySQL, etc.
STEP 2: Create a database named todo_app and fill it with these columns: (…)
STEP 3: Define a data structure for each TODO item
STEP 4: Etc…

Note that each of these steps is directly correlated to a particular skill

STEP 1: Install prerequisites
This teaches you how to get Node, MySQL, and other tools on your machine

STEP 2: Create a database
This teaches you MySQL basics, querying, altering, updating columns, etc.

STEP 3: Define a data structure
This teaches you how to define data for your todo app, and creates a bigger picture of how data works in and out of MySQL…

A good tutorial will clearly break down a seemingly large task (building a todo app) and put them into smaller chunks for you to consume and learn from.

Deconstructing and Breaking Down a Task

You’ve been instructed to build a really long page with lots of marketing information for your company. The server and route are already set up. You just need to build out the HTML, CSS, and Javascript for this page. You’ve been given a photoshop mock of what the site will be and all your assets like photos, videos, and fonts have been provided for you.

It’s silly to think that this would be the approach:
STEP 1: BUILD A REALLY LARGE PAGE

That won’t work. Break it up into smaller tasks like we did our TODO App:

STEP 1: Identify common/repeated elements on the page.
STEP 2:
Create CSS classes for these common/repeated elements.
STEP 3: Start with building out the mobile version for the first top section on the page
STEP 4: Build out the desktop version for the first top section of the page.
STEP 5: Move onto the section below.
Rinse and repeat.

Break down the task. Identify the first step. Identify what action needs to be done. Then execute.

Figure out that first step and what needs to get done, then when that’s done, move onto the next.

If you don’t know what step 1 should be or have absolutely no clue on where to go, then you’re probably in a good spot to hunt for a tutorial.

If you DO know what step 1 should be, then you shouldn’t be using a tutorial in the first place. Use knowledge from your past tutorials and projects to start this task.

At the end of the day, you’re not looking for tutorials, you’re looking for step one. Stop hunting for a tutorial, and start thinking critically about the tasks at hand to accomplish what you’re trying to build.

When your task is done, and you feel good about this project or can foresee the next iteration of your project — Break down the task. Identify the first step. Identify what action needs to be done. Then execute.

Through Algorithms

Algorithms are given during a programming interview because the interviewer is specifically testing this capability in younger developers. If I give you a task, how do you break it down?

Take this simple algorithm challenge:

“Write a function that takes in a string and returns it in reverse”

The more inexperienced developers will immediate go to Google and search for, “How to reverse a string in [language]” — but that’s not the point here. While if it’s your first algorithm challenge, this makes sense, it’s not really the point here.

There’s multiple ways to do this. You can do it with Array methods, or with a for loop that goes in reverse. Either way it’s done, you’ll need to break down the task into smaller bits.

function reverseString(string) {
/*
I want to use Array.prototype.reverse() to do this. I need
to start off by turning the string into an array.
*/
// STEP 1: Turn the string into an array.
const array = string.split('');
// STEP 2: I need to reverse this array.
const reversed = array.reverse();
// STEP 3: I need to turn this array back into a string.
const reversedString = reversed.join('');
// STEP 4: I'm done. Return the newly reversed string
return reversedString;
}

This type of critical thinking and ability to break down larger tasks into smaller ones is essential to day-to-day developer work. It’s a proper representation of what we do as software engineers.

Each task that finished makes you a better developer just by a little bit, and some tasks more than others. The more foreign the task, the better you get, and being a better developer is an everyday goal in this line of work.

I Don’t Know Step #1… I Need to use a Tutorial!

If you have to use a tutorial, that’s fine, but if you have to google “How to reverse a string” and see some method or approach you’re not familiar with, then you’ll need to find out what that method or approach is. You must know what your code does. Copying and pasting in someone else’s code not knowing what’s happening is a sweet shortcut to cheating yourself out of the opportunity to learn something new. This careless approach takes the potential knowledge to be gained from the tutorial into waste. Know the how and why this code works, and like each task finished makes you a better developer — each foreign method that’s not-so-foreign anymore makes you an even better developer than you were before. Remember what you learned from every experience, and use this newfound knowledge when a similar situation arises in the future.

Trust me, you’ll have to use it sometime 😜.

Closing Thoughts

The best developers I’ve met and worked with are the ones who are hungry for knowledge, and hold an insatiable appetite for learning more, building up their skills, and playing around with cool new technologies that they want to learn. The knowledge from project #1 carries over to project #2, and project #3, and project #29, and so on, and on, and on…

After long enough, you’ll find the need for tutorials on completely foreign concepts where you just don’t know where step 1 is, but the more foreign the concept, the greater the challenge which reaps a larger reward and depth of knowledge.

Continue this cycle, and enjoy the process of continual self-development and mastery in programming. There’s no shortage of stuff to learn, and the only thing that never changes, is that everything will change.

Stay hungry, stay curious, and bring out the best in yourself through applying knowledge. Think critically, and execute your skills with graceful precision that will only get sharper and stronger over repeated and continual practice.

Written by

Javascript Developer and Software Engineer. I write longer(ish) articles on technology, career development, writing, and anything that comes to mind :)

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store