How To Teach Yourself To Do Anything
Tags: beginners, productivity, tutorial, codenewbie
Published: 2021-03-01 02:48:20

Living in an advanced world allows us to access information on anything we desire in milliseconds. Using browsers and search engines we can easily browse the web over tons of documents and find relevant data.

> For example: go search *potato* on google, you might see a response of `About 539,000,000 results (0.87 seconds)`

And we could scroll through all of these millions of documents if we really wanted too. Who knows we would probably find some really interesting things about potatoes.

Putting *the potatoes aside* and getting back to the relevant topic, we can use these tools to access free educational material! Pretty awesome if you want to be a self-taught learner of anything. 

In this 'guide' I am going to provide some tips on how I teach myself programming languages, frameworks, tools, etc. using only the internet, but some of the tips could be helpful if your trying to learn anything else! 

---

# Table Of Contents
* [About Me](#about-me) - Some basic information on my past experiences.
* [Understanding the Lingo](#understanding-the-lingo) - Your first stop for learning something new.
  * [Read the Docs](#read-the-docs)
  * [Encountering Our First Unknown Term](#encountering-our-first-unknown-term)
* [The Art of Googling](#the-art-of-googling) - Become a googling pro.
  * [Searching With Relevance](#searching-with-relevance)
  * [Navigating The Sea Of Search Results](#navigating-the-sea-of-search-results)
* [What To Do When I Have Errors](#what-to-do-when-i-have-errors) - Reading stack traces, debugging, and where to get help.
* [Keeping Up The Pace](#keeping-up-the-pace) - How to stay motivated to achieve your goal.
  * [Setting Attainable Goals](#setting-attainable-goals)
  * [Managing Our Time](#managing-our-time)
  * [Finding Our Happy Place](#finding-our-happy-place)
* [Experimentation](#Experimentation) - Implementing our new found ideas.
  * [Build As You Learn](#build-as-you-learn)
  * [Make Open Source Projects](#make-open-source-projects)
* [Discussion](#discussion) - Some talking points for this thread.
* [Credits](#credits) - Any credits needed related to this post.

---

## About Me
I have been teaching myself a plethora of things using the internet ever since a young age. I started learning java when I was just 11 years old, but the internet can be used to learn anything! From my favorite meatball recipe to finding an awesome hiking trail near by, it doesn't only apply to programming. 

Ever since starting programming at a young age I used tools such as CodeAcademy and W3Schools to get a basic understanding of Object Oriented Programming and learning a couple languages such as HTML and CSS. From there I went and taught myself Java, SQL, MongoDB, C++, and more, since the school I went to did not offer any courses in technology. 

I am currently taking self-paced online courses at the [Flatiron School](https://flatironschool.com/), and utilizing what I've learned from teaching myself in the past has significantly helped me gain a deep understanding of the large amount of new material we are expected to cover. 

I hope this guide can help any of my fellow students in the self-paced program on how you can teach yourself and blaze through learning new tools, programming languages, or anything!

---

## Understanding The Lingo
One of the most confusing aspects of learning any tool, language, or framework is getting used to the terminology it utilizes and understanding it deeply.

In my own experience, this is the hardest when switching between different programming languages due to the different syntax used and [many](https://www.cprogramming.com/langs.html) other uses for them. Whereas a **tool**, for example SQL, will have similar (and most likely exactly the same) functionality within any programming language, using SQL's **lingo**.

So how do we get a basic understanding of a tool, language, or frameworks lingo?

---

### Read the Docs
Before starting to learn anything, you would need to understand the pre-requisites. 

For example, you probably shouldn't start learning algebra without knowing pre-algebra. Or what if your spinal surgeon just switched over from being an orthodontist? You might say:
> Hey, are you qualified for this?

This is the same way tools, languages, and frameworks expect us to function. We get used to the specific lingo by starting with the documentation. 

A great example of an **amazing** documentation would be by the web application framework [Ruby On Rails](https://guides.rubyonrails.org/getting_started.html). Go ahead and take a look.

When you click on the link you'll find a section right at the beginning that states **Guide Assumptions**. This is the pre-requisite section that most documentation will have under a similar name. 

> Do I have to read the entire documentation?

No, but you could if you have nothing better to do, use this as your starting point and reference point. Most documentation will have a getting started section that will help you start using whatever service they are offering. As you use the service, come back to the documentation when you want to learn about something new or if you are running into issues. 

You might find something really cool hidden within the docs that make your life way easier!

Depending on the [level of abstraction](https://en.wikipedia.org/wiki/Abstraction_(computer_science)) this could be where you run into your first bizarre looking term. 
> What's a web application? What's Rails?

Don't freak out! Learning the lingo and requirements is the first step in getting a **deep understanding** of any tool, language, or framework. 

---

### Encountering Our First Unknown Term
Well... It may be discouraging, you have to do some more research before you can even start learning. Yet the payout will be huge down the road, and you can read some more on the [importance of terminology](http://www.computing.surrey.ac.uk/ai/pointer/report/section1.html) if you still aren't convinced.

Our first step would be to [google the term](#the-art-of-googling). This usually will bring up the documentation page for the specific term, a definition, or link us to stack overflows or github projects that use this terminology. 

> Why is this important? 

We now have context for what we are trying to learn and how it can be used in the real world.

Our second step is to then try and use the term. For example if you are finding yourself learning any new word you would want to be able to use it in a sentence. The same thing goes for programming lingo, we should be able to use it in a viable way that mimics real world logic.

> A side note that some lingo may not do anything, although it can be a term that is used frequently within a specific language, tool, or frameworks documentation and understanding it will be necessary to continue.

This could be shown if you were using MySQL and wanted to learn about the `CREATE TABLE` method. MySQL syntax is very logical, so a sentence like `I would like to CREATE a TABLE of cats.` could seem reasonable. Now let's look at how we would do that in MySQL `CREATE TABLE cats`. 

Logical enough, but now that we have translated our understanding into the tools specific lingo, how do we use it?

Finally we would want to implement this an experiment until we feel comfortable with how the lingo translates into functionality. Read more on experimentation [here](#Experimentation).

---

## The Art of Googling
When teaching yourself google is your guide through a massive amount of completely free education material! 

Since there is so much material out there, and we are also going to be learning a variety of things we need to be able to google like an expert.

---

### Searching With Relevance
Whatever we are trying to learn we need to search for something relevant. 

For example if we were in the midst of learning Ruby and were stuck on string concatenations (follow along if you haven't heard of concatenations you'll learn something new), a google search of `Ruby String examples` probably isn't what we would want to search. 

Let's make sure we are searching for [Ruby String concatenation](https://www.google.com/search?q=ruby+string+concatenation), or whatever our relevant topics would be. If we were in Java, it would make sense to search for `Java String concatenation` and so on. 

> [Helpful Google Guide](https://www.howtogeek.com/106718/how-to-search-google-like-a-pro-11-tricks-you-have-to-know/) - HowToGeek

Well now that we have all of these great search results, what do we do?

---

### Navigating the Sea of Search Results
We have to always think back to our relevance when navigating the vast sea of search results. Following our example from above, we are on the ruby programming language so if we see a site, for example [rubyguides.com](https://www.rubyguides.com/2019/07/ruby-string-concatenation/), that is most likely going to be a decent guide.

One notable site for getting help and more knowledge of any tool, language, framework and to keep a heads up for is [StackOverflow](https://stackoverflow.com/). This is a great place to go when experiencing technical issues, bugs, etc. More in the [What To Do When I Have Errors](#what-to-do-when-i-have-errors) section.

You should also look for GitHub and GitLab examples, as these can further your understanding of the real world usage of what you are trying to learn.

> If you want to learn a language, using a website like [W3Schools](https://www.w3schools.com/) or [Code Academy](https://www.codecademy.com/), are very great places to start. As they help introduce the languages to you at a beginners level.

---

## What To Do When I Have Errors
Errors are frustrating. Sometimes you can't figure out what you did wrong.

First thing is first, always read the `stack trace` they might seem scary, but they are actually your best friend! These contain information that tell us exactly what is going wrong. You can read up some more on how these really help you debug your code or application here:
> [The Dreaded Stack Trace](https://jgefroh.medium.com/the-dreaded-stack-trace-2692c053b28e)

Second thing, once we understand our errors we have to decide if its logical error, syntax error, runtime error. 
> **Syntax Error** is when we typed something that the interpreter didn't like. 
> **Runtime Error** is a little more advanced, usually the generic error type and takes some more debugging.
> **Logical Error** is us making a mistake with how our program or application functions. These can fall under a runtime error or not raise errors at all.

Fixing syntax errors is the easiest as our interpreter will usually tell us the exact file and line that it struggled to read.

When it comes to the Runtime errors is when things can get difficult. I always ask myself: 
> Am I infinitely looping? Am I incorrectly using an external tool?

For example lets say I have this code:

```Ruby
def say_hello_five_times
  x = 0
  while x <= 5
    puts 'Hello'
    x += 1
  end
end

say_hello_five_times
```

It won't raise any errors, but you may notice you don't get the desired output. That's where we have to give our code what I like to call **a walkthrough**.

> We walkthrough our code like the computer would, this helps us understand the code we have written and how the computer actually reads that.

```Ruby
# define a method (say_hello_five_times)
def say_hello_five_times
  # set a variable x to 0
  x = 0
  # Loop x until it is equal to 5
  while x <= 5
    # print 'Hello'
    puts 'Hello'
    # increase X (0 -> 1 -> 2 -> 3 -> 4 -> 5)
    x += 1 
  end
end

# call the say_hello_five_times method
say_hello_five_times
```

And wait a second now we can see that the computer is looping through 6 times. We would need to change our `<=` to `<`. This is a very basic example but walking through like the computer would is a great way to find logical errors in your code.

You can even test parts of your code on [Repl.it](https://www.repl.it) which is very helpful for quickly debugging portions of larger applications, or even testing something before adding it to your local project.

After giving your code a quick walkthrough and running through the application as your computer would. If you are still running into errors, it's time to outsource to our good friend google. 

Searching the exact error from our stack trace can lead us to other people who encountered similar issues (*hint: stack overflow is where you want to look here*) or even searching it using our [pro googling skills](#the-art-of-googling).

If you are lucky enough to be a part of a community that you can reach out to and get individual help on, that is great too, but try solving it yourself first!

If you can't find any solutions make a post on Stack Overflow. This won't only help you, but anyone else who runs into the issue in the future.

---

## Keeping Up The Pace
Learning can be tiring, especially if we are filling this in during our other daily activities. Time management skills are necessary to be a self-taught learner.

---

### Setting Attainable Goals
One way that I hold myself accountable is first to set a goal. This will help you feel like you've achieved something when you reach it, no matter how little or big of a win! 

Start with the big picture, for example if you want to be the best chef in the world that's a great goal. Sadly you don't know how to cook yet or where to get one of those fancy hats. That's where we need to set our sub-goals.

For my main goal of becoming a full-stack software developer, would contain many sub-goals such as: learning Ruby, HTML, CSS, learn how to host a web application, learn ruby on rails, etc. 

If you're a student at the Flatiron school like me, I separate the sections out as my sub-goals either for the day or the week depending on the amount of content.

---

### Managing Our Time
If you want to complete your main goal in a year and you have all these different sub-goals, while working, or attending school, etc. it may seem stressful. This is where time management is key. 

It all depends on how fast you want to learn (since we are self-taught learners), but consistency is key. If you want to dedicate at least an hour a day to learning something new, stick with it. Find yourself bored in the middle of the day? **Time to learn something.** Have a project you've been pushing off all week and can't sleep? Don't start watching that new Netflix show, you could read about something that can help you with the project, or find a video with some relevance to what your learning. Find a new tool to add to your project, or even work on it. 

Learning can be tiring, so we can make it fun or trick ourselves into relaxing while still learning!

---

### Finding Our Happy Place
You might be thinking:
> AJ, you really want me to stop binging that Netflix show and learn something! How will I ever survive?!?! 

We all have our own happy place, and if it's curling up in bed and watching your favorite movie or tv show then I'm not here to judge or tell you to stop. Having this relief of relaxation, no matter what way you do it, is absolutely necessary for not getting burnt out. Both in our daily lives and whilst we are learning.

Some of the ways I like to relax are by going on a hike, listening to music, or hanging out with my friends to watch a movie. Find whatever it is that is your happy place and dedicate a little bit of time out of your week to make sure you go there.

This is *extremely* important. If you are feeling overwhelmed or stress, take a step back, breathe, and then come back to it later. 

---

## Experimentation
When we are learning a vast amount of things at a fast pace, it's easy to lose knowledge of something you learned before and don't use much anymore. This is where experimentation can come into play.

---

### Build As You Learn
As you are learning whatever it may be, you should try to implement this outside of just your learning environment. 

For example, if you still wanted to be the best chef in the world you could read up on all the best recipes and then not know how to put it together!

Within learning software development it's the same way. 

> Implementing and experimenting with what we learn is a great way of gaining a deeper understanding of a subject and gives us real world context and usage for it.

My favorite way to do this is by creating [repl's](https://www.repl.it) for new subjects and trying to expand it on my own before moving to the next step. 

For my fellow students at Flatiron, or others learning software development, this could be by trying to raise the level of abstraction before moving to a higher leveled framework. This helps you gain a very deep understanding of how these frameworks actually function off of each other.

---

### Make Open Source Projects
This is a great way to get used to working with teams (some all the way around the world) and learning in a collaborative environment. 

Open-Sourcing your work, especially while learning, is a great way to build a portfolio and get experience in the field your studying. Having it be open source lets other people like you who want to learn about similar projects use yours as learning material.

---

### Discussion
A couple points for discussion that I would love to here from the community are:
* What are your favorite ways to relax? (ie: your happy place!)
* What tools have you found useful in your self-teaching experience?
* What's a win you've had recently? (ie: something new you've learnt or built.)


---

### Credits
* [Header Image](https://www.freepik.com/free-vector/education-horizontal-typography-banner-set-with-learning-knowledge-symbols-flat-illustration_6871644.htm) - Designed by [macrovector](https://www.freepik.com/macrovector) / [Freepik](https://www.freepik.com/)

Found an error? Please reach out either on this thread or to me personally so I can fix it.