Want to learn how to code? Start here.

Who is this course for?
This course has zero prerequisites. I have designed it for the complete beginner and although you will not be fluent in C, Java, Javascript or Python (etc.) by the end of it, you will have a roadmap to guide you for months, or even years to come. The goal of this tutorial is not to make you proficient in any one area but to expose you to many of the things you will encounter as a programmer.
With that in mind, this tutorial is also not going to be a massive resource list. I know there are plenty of resources to learn how to code out there, and honestly, there are plenty of awesome resources. Learning to code is not a matter of finding the good stuff but rather being selective and disciplined to know when enough is enough. This tutorial will provide tools and resources, but not so many that you feel overwhelmed.
As stated, this tutorial will not suddenly turn you into a proficient programmer, but I do believe if you follow along intently and commit yourself to completing the courses and resources mentioned at the end of the post, you will become a proficient programmer. This stuff can be challenging at first, so have patience, keep your expectations in check, and most importantly, enjoy the process of learning to code!
This is a skill that will change the way you live, work, and think.
Along the way, you will have tons of challenges, but the daily successes that coding offers will keep you going!
Github Repository
Although I would assume many viewers of this tutorial are not familiar with Github, I have included something called a repository alongside this post. A repository is just a fancy word for a folder with a bunch of folders and files in it.
Github is the site that hosts thousands of repositories from thousands of developers across the world. There is a huge difference between Github the website and git the software. Github just happens to use git and be the most popular website for hosting code and collaborating on projects. The actual git software is used on other code hosting sites like Gitlab, Bitbucket, Sourceforge, or even a custom host! When I refer to “git”, I am talking about the specification that allows you to manage versions of projects, which is something you will use for the rest of your coding life.
If none of that made sense, get used to it and keep reading.
Topics
Throughout this crash course, we will be covering the following topics.
- Can Anyone Code?
- What Language Should I Learn First?
- What is Coding Anyways??
- Brief Introduction to How a Computer Works
- Recap: How a Computer Works
- Let’s clone a Github repository!
- Web / App Developer
- Networking Engineer / Systems Engineer / Security Engineer
- Data Scientist / AI / Deep Learning
- Other
Can Anyone Code?
Ahhh… One of the most popular questions among aspiring programmers. I have a dead-simple answer for you.
YES.
Some people are going to be better than others, but please don’t let doubts about your intelligence prevent you from teaching yourself to code. Believe it or not, your brain is “coding” every day of your life.
A great example of this is the task of cleaning your room. Everything on your floor needs to be put away, and different items will be put away in different locations. For simplicity, we will assume that everything on your floor will either go in your closet or in the trash. Here is our program for cleaning our room written in “pseudocode”:
For Each Item on the floor:
If Item is a piece of clothing:
fold it
else
throw it away
Pseudocode is a type of code that is not written in a specific language and would not actually work if you tried to run it, but it does lay out the basic logic that you want your code to follow.
Many programmers will first write the pseudocode for their program and then turn that into real code. We will be turning this pseudocode into a real program later in this tutorial.
Although what you just read may look slightly odd, we have demonstrated that the human brain “codes” every day, all day. To clean our room, we are “looping” through each item on the floor and performing an “if-then” logical statement to decide based on a condition (whether it is a piece of clothing or not) what we want to do with the current item from the floor.
This example may sound trivial and easy, but once we dive into the actual act of writing code, you will find it hard to see the big picture like this. So returning to the original question of “Can anyone code?”–If you can clean your room, then you can code.
You just need to be willing to devote a large amount of time upfront to learn how to instruct your computer to do what you want it to do. In short, quit wondering if you are capable of this thing we call “coding” and just START.
What Language Should I Learn First?
At one point, I was a culprit of asking this question, but I’m here to tell you to STOP ASKING THIS QUESTION.
You will soon find out that most programming languages work in a similar way to one another and therefore your understanding of one will translate fairly smoothly to another. Just follow along with the tutorial and absorb the concepts as best you can. You can come back to this question later.
If you are like me, you at least want to know some of the popular languages, so here is a very shortlist. 99% of you will be writing code in one of these languages at some point.
- Python
- Javascript
- Java (no relation to javascript)
- PHP
- C / C++
- Ruby
What is Coding Anyways??
Later, we will go into some of the different professions you can do as a coder, but from a 10,000-foot view, what is coding?
You will get many different answers to this question because coding is not one thing. At its core, code is simply some text sitting in some file that a human has written. It sounds boring, but from this simple concept, we have created cars that drive themselves, a worldwide web that connects humans across the globe, and robots that can dance better than myself.
In my opinion, code is just a generic word we use in an attempt to conceptualize a topic that is far too complex to explain in a single sentence. I have found that explaining what code is can be futile without more context on the subject, so let’s dive in!
Brief Introduction to How a Computer Works
When I first started learning to code, it troubled me that I did not understand how the computer I was coding on worked. Although you would need years of study to fully understand the inner workings of a computer, I wanted to explain the very basics of it before we start learning how to code. Once you have mastered the basics of coding, there is a book/course called Nand 2 Tetris that is a great resource for learning this topic.
As a forewarning, this book/course will take you several weeks or even months to finish, and requires at least a small amount of background in coding to complete. I do not suggest starting your coding journey with this course but I wanted to mention it here because it is at the top of my reading list for when you do start to get the hang of this stuff.
So how does your computer display a YouTube video in HD? How does your computer download Gigabytes of data in just a few minutes? How does your computer calculate complex numbers in milliseconds?
Abstractions
To understand a computer, you need to be able to understand what an “abstraction” is. In day to day life, we see abstractions all the time. For example, when you turn on the shower in the morning, that is an abstraction.
Naturally, the water will not come out of the faucet. To make this happen, water has to be collected, directed to your house, heated, and finally sent through pipes until you find yourself taking a nice hot shower. Every time you get into the shower, you blindly expect that turning the knob will instantly start the water. The end-user of the shower (you) only needs to know how to turn the knob. The rest of the process is taken care of by either automated equipment or a water company.
Coding works the same way. You start with something readable and end with 1s and 0s. Go ahead and follow the steps below.
Step 1
Sign up for a free account on AWS Cloud9 .
We are doing this to avoid having to download and configure our local computers to run the code I am about to show. We will talk about coding environments later in the tutorial, but for now, you are going to have to just go with it. As you learn more about coding, you will realize how much of a pain it can be to get everyone’s computer working the same.
Step 2
Create a new “Environment”, and enter the settings in the screenshots below.



Once loaded, you should see a screen that looks similar to the one below. You can close the file that opens automatically.

First, create a new file called hello.c
by typing the following command into the terminal at the bottom of the screen.
touch hello.c

After doing this, you will see this new file in the left-hand file pane. Double click it to open, and paste in the code directly below this sentence. Save the file.
#include <stdio.h>
int main() {
printf("Hello World!\n");
}

This is a super simple C (the C programming language) program that will print the phrase “Hello World” to your terminal when you execute it. So far, although the code may look a bit unfamiliar, anyone could interpret the general idea of what this program does. You could reasonably guess that main()
is the name of the function and printf()
will print something somewhere. There is just one problem… How is our computer going to read this??
- In the terminal at the bottom of the screen, type the following command and press Enter.
gcc -S hello.c
Did you catch that? In the left-hand file pane, a new file was created called hello.s
Go ahead and open that file up. You will see several more lines of code, but this time, the code is not so intuitive.
.file "hello-c-world.c"
.section .rodata
.LC0:
.string "Hello World!"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $.LC0, %edi
call puts
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4"
.section .note.GNU-stack,"",@progbits
This is what we call “assembly code”. We are now one step closer to being able to execute our code file with our physical computer. In the above command, we used the GCC compiler to convert our human-readable C code into some more abstract version of code.
When I say “GCC Compiler”, it sounds like I am referring to some physical object. In reality, the GCC compiler is simply hundreds of lines of code (you can see them here). In other words, we are using pre-written code to compile our code. It can get confusing to say this, but we are using code to convert our code into machine code.
In the terminal at the bottom of the screen, type the following command and press Enter.
gcc -o my-first-program hello.c
In the previous step, we asked the compiler (GCC) to convert our C code into assembly code and then stop there. Instead of doing that, the above command will tell the GCC compiler:
“Hey GCC compiler! Instead of first compiling this to assembly code and saving it to hello.s
, can you just convert it to binary code all in one pass?”
After running this command, there is now a file called my-first-program
. Double click on this file to open it. You will see a bunch of symbols and characters that make absolutely no sense at all.
>@@@x@8 @@@@@@��88@8@@@�� ``08 ((`(`��TT@T@DDP�td��@�@44Q�tdR�td``��/lib64/ld-linux-x86-64.so.2GNUGNUD�;���y��7Ԡ1I�J>" libc.so.6puts__libc_start_main__gmon_start__GLIBC_2.2.5ui 1�`` `(`H��H�
H��t�;H����5 �% @�% h������%� h������%� h�����1�I��^H��H���PTI���@H��@@H��-@�����fD�G`UH-@`H��H��w]øH��t�]�@`����@`UH-@`H��H��H��H��?H�H��u]úH��t�]H�ƿ@`����=Y uUH���~���]�F ��@H�= t�H��tU� `H����]�{����s���UH���@�����]�AWA��AVI��AUI��ATL�%� UH�-� SL)�1�H��H���m���H��t�L��L��D��A��H��H9�u�H��[]AA]A^A_�ff.���H��H���Hello World!;0,���|l���LY����l��������zRx����*zRx�$����@FJw�?;*3$"D����A�C
KDd����eB�E�E �E(�H0�H8�M@l8A0A(B BBB�����
These are actually 1s and 0s, but the text editor cannot understand them and prints nonsense. At this point, we have finally converted our original program into 1s and 0s which the computer can read, but how does the computer know how to read 1s and 0s?
Well, a computer is composed of transistors, which are neat little devices (super small) that fire binary signals (i.e. 1 or 0, true or false, white or black, etc.).
Since we know there are only two states a transistor can be in (1 or 0), we can design a computer chip (the CPU, or “Central Processing Unit”) that can read a sequence of 1s and 0s and turn them into letters, numbers, and pixels on the screen. Again, I do not have time to go into this more deeply, but if you’re so curious you cannot contain yourself, read Charles Petzold’s “Code” book.
In the terminal at the bottom of the screen, type the following command and press Enter.
./my-first-program
When you pressed Enter, you should have seen “Hello World” print to the terminal. The computer has read the 1s and 0s contained in your binary file and converted them to letters!
Quick tip: In the programming world, when a program prints to the terminal this is also referred to as printing to “stdout”. This will make more sense later on in the tutorial.
If we take a step back, we can see how hundreds of different programming languages are possible. Heck, we could make up a language! Here’s an idea:
print "Hello World"
How simple is that? As long as we can convert that line of text into the same 1s and 0s that our C program was converted to, we have just invented a language! Unfortunately, this language has already been invented, and it is called Python. The Python interpreter (similar to GCC compiler) will read this line of text and convert it to the same 1s and 0s that the GCC compile converted our C program to, and thus will do the same exact thing when executed in the terminal.
Don’t believe me? Try it for yourself. First, create a new Python file by typing the following command into the terminal.
touch hello.py
The .py
at the end of the file indicates to programmers and computers that there is python code within the file.
Open the file by double-clicking it in the left-hand pane, and put the following code in it and save.
print ("Hello, World")
Now run this program by typing the following into the terminal.
python hello.py
Like I explained, this does the exact same thing as the C program, but with a lot less code! If you’ve been paying attention, this is a prime example of “abstraction”.
Recap: How a Computer Works
Although this was a very brief explanation of how a computer works, the main thing I want you to take away is the fact that all programming languages eventually end up looking exactly the same. Sure, there are different CPUs (Linux vs. Mac vs. Windows) that have slightly different requirements for those 1s and 0s, but as a generalization, it is safe to say that all programming languages end up looking identical at the lowest level of abstraction.
Resources Mentioned in this Section
Let’s clone a Github repository!
To reiterate, for this tutorial, we will be using a “hosted” environment called AWS (Amazon Web Services) Cloud9.
We are doing this because it comes with a bunch of stuff pre-installed for us, which makes it easy to start coding without a lot of setup. For example, if you were coding on your laptop, you would need to manually install Python to your computer. Since everyone’s computer is slightly different, this installation process can be a bit tricky. By using Cloud9, we have eliminated this hassle so that we can focus on learning what coding is all about.
You already have your workspace created, but you will need to do a few more things to continue forward.
- If you have not already, go to Github and create an account
- Once signed in to Github, go to this link
- In the upper right corner of the screen, click the button that says “Fork”. This will clone a copy of my sample repository to your account so you can edit it.
- Once the fork has finished, navigate to your newly created repository and find the button that says “Clone or download”. Click this button to copy the link to the repository.
- Go back to Cloud9 and type the following code into the terminal (replacing the link with your own)
git clone https://github.com/zachgoll/how-to-code-1-hour-crash-course.git repo
Let’s recap what we have just done. We first “forked” my repository, which is basically like copying a folder from one Github account to another. We then “cloned” it to our workspace using the Git utility, which takes all of the files from the repository and copies them to the workspace. You can see what each piece of this command means below.
git clone <link> <name>
By typing git
, we are telling our computer to use the Git utility that was already installed for us when we setup Cloud9. The clone
keyword is a “function” that the Git utility allows. The <link>
part is where you paste in the HTTPS link of the repository you want to clone. And finally, the <name>
part determines the name of the directory that will store the contents of this repository.
If you did everything right, you should see the repository in a folder called repo
, which stands for “repository”

Basics of Coding
No matter what language you are writing code in, there are just a few concepts that you must understand. If you can understand these few essentials, you will be able to learn any coding language. To better conceptualize the basics, we will return to our room cleaning exercise and actually put it into code!
I know I know. This is a lot of code to look at! Take a quick read through the file and we will be coming back to it throughout the remainder of this post. But first, we need to learn a little more about this “command line” we have been typing commands into.
What is the Command-Line?
You may have noticed that during the course of this tutorial we have already typed some commands into the command line. I’m here to tell you to get used to it because the command line is used for all types of coding whether it be machine learning or front-end web development. The command line is a powerful utility and allows you to do common tasks such as:
- Create/Delete folders
- Create/Delete/Modify files
- Set permissions on files and folders
- Print the contents of files
- Interact with Github through the Git utility
- Download software packages
- Run your applications
- etc.
If I asked you to run the program above, how would you do it?
First, you need to get your “working directory” to match the “path” of the program. Then you need to run the program using the Python interpreter. Sound like jibberish?
Step 1: Change your Working Directory
When you first login to your Cloud9 workspace, in the terminal area, you will see something like:

Since our Cloud9 server that we setup earlier is a Linux server, by default, this area will accept a scripting language called Bash.
What is Bash? Well, that’s what we’re here to find out. In short, Bash is a human-friendly language that we can use to navigate and modify the filesystem with.
You’ve probably seen something like this before:

This is a Windows 10 File Explorer, and although Windows works slightly different than a Linux (what we are using) or a Mac operating system, all of these filesystems have the concept of “hierarchy”.
To understand this, go to the terminal in your Cloud9 Workspace, and print the “current working directory” by typing pwd
into the terminal and pressing enter.
It should print /home/ubuntu/environment
.

What we just printed is called a path. Take a look at the Windows file explorer again.

Again, the commands are not exactly the same for Windows, Linux, and Mac, but if we were to determine what our current working directory was using the filesystem above, we could pretty easily conclude that it is:
"E:\Filesystem Example\Parent Folder\"
Don’t worry that the syntax is different, just focus on the hierarchical aspects of what is going on. The current working directory represents the path that we are currently located at.
So when we are typing all of these commands in the Bash terminal, just remember that all we are doing is navigating the filesystem of the computer.
Going back to our example, we have one problem… If the current working directory is /home/ubuntu/environment
, then why does it say ~/environment
?
Well, every computer has what we call a home directory, and you can navigate to it by typing the following command.
cd ~
Or… (command below gets the same result)
cd
In other words, ~/
is a path and it is equivalent to the path/home/ubuntu/
on this particular machine.
Our goal is to get the path of our current working directory that can be found by typing pwd
(print working directory) to match the path of our Python program (if you forgot, our end goal here is to get our Python program to run).
Look at the folders and files in the left-hand pane. Click the folder that says source-code
. You will see the file called clean-room.py
. Notice the path that this file sits at, which we could figure out just by looking at this left-hand pane.

Just by looking at the filesystem pane, we know where our file is:
/home/ubuntu/environment/repo/source-code/clean-room.py
Our goal is to use the terminal to find this path and then execute the program.
Now type the following two commands into the terminal.
cd ~/
ls
The cd
command will “change directory” to the supplied path. We typed cd ~/
but we very well could have typed cd /home/ubuntu/
or cd
to get the same result (if you haven’t caught on, there are many ways to do things in coding).
The ls
command will “list” all of the files and folders located in your current working directory. In this case, you should see two directories and a file.
~/environment/
~/node_modules/
~/package-lock.json
Don’t worry about what these are right now.

All our files are in the /environment
directory, so let’s navigate there by typing
cd environment# This is a command-line (bash) comment, and doesn't do anything
# I can use these comments to explain things without affecting
# the commands that I am writing# You can also type the following commands which are equivalent
cd ~/environment
cd /home/ubuntu/environment
Type ls
again and you should now see some new folders and files.
~/environment/README.md
~/environment/hello.c
~/environment/hello.py
~/environment/hello.s
~/environment/my-first-program # this is a binary file
~/environment/repo/

You can see all of the files and folders that we have created so far alongside the Github repository we cloned.
But if you look in that left-hand pane where all the files are listed, you will probably see files like .git
and .c9
and .github
. What are these, and why do they not show up when we type the ls
command?
These are considered hidden directories and files because they are preceded with a dot.
We can display them by typing the command ls -la
. By adding some additional options to the ls
command, we can learn more about the files and folders.
Quick Tip: You can type clear
into the terminal to clear the contents. In the next screenshot, you will see that I have cleared the contents of the terminal and then run the next command.

As you can see, by adding the -la
options, it prints ALL files and folders. We will later explore what command-line options are, so don’t worry if this makes no sense.
Finally, let’s navigate to the source-code
folder of the Github repository. As a quick check, when you type pwd
you should see /home/ubuntu/environment
. If you don’t see this, make sure to return to this path by typing EITHER of the following commands.
cd ~/environment# ORcd /home/ubuntu/environment
Now, type ANY of the following commands to get yourself to the source-code
directory.
cd repo/source-code# ORcd ./repo/source-code# ORcd ~/environment/repo/source-code# ORcd /home/ubuntu/environment/repo/source-code
These will all translate to the same path. Type ls
and you will see the clean-room.py
file among others.
Run the file by typing:
python clean-room.py
You should receive some sort of text output like so:
Program: clean room program
----------------------------------------
I put the hoodie in my dresser!
I put the t-shirt in my dresser!
I threw the orange peel in the trash can!
I threw the gum wrapper in the trash can!
So why did we have to navigate to the same directory the program is in to run it? We didn’t actually need to do this. We did this for simplicity, but we could have also run the program with any of the following commands.
Remember, our current working directory has a path of /home/ubuntu/environment/repo/source-code/
, which you could always verify by typing pwd
into the terminal.
python clean-room.py# OR python ./clean-room.py# OR python /home/ubuntu/environment/repo/source-code/clean-room.py # ORpython ~/workspace/how-to-code-1-hour-crash-course/source-code/clean-room.py
In other words, our command that we used to run the Python file has two parts.
<interpreter> <file path>
For the interpreter, we need to specify that we want to use the Python interpreter to run our Python file. If you remember from earlier, when we wanted to run our hello.c
file, we needed to use the GCC interpreter.
For the file path, we need to let the Python interpreter know where it can find the python file to run!
At this point, you are probably feeling a bit confused, and that is okay. To recap, we have talked about the current working directory, a path, the cd
command, and the ls
command.
We started with these four terms/commands because without them, you can’t do anything else on the command line.
To take your understanding further, you also need to understand the difference between an absolute path and a relative path.
Absolute vs. Relative Path
Type the following command.
cd /home/ubuntu/
From this path, what is the relative path to the clean-room.py
program?
The relative path would be the following:
./environment/repo/source-code/clean-room.py
The key to understanding this is to know what the ./
does. By including ./
at the beginning of any path, you are telling the Bash shell that you want it to replace these characters with your current working directory.
What’s our current working directory in this situation? Type pwd
and you’ll see that it is:
/home/ubuntu/
Now if you take this and substitute it in with our relative path, you will get:
# Relative path
./environment/repo/source-code/clean-room.py# Now replace ./ with the current working directory of /home/ubuntu/# Absolute path
/home/ubuntu/environment/repo/source-code/clean-room.py
This represents the absolute path to the same file! We can type either the relative path or the absolute path when navigating in the Bash shell, but usually, the relative path is much simpler and shorter to type.
From this directory, we could run our Python program with:
python ./environment/repo/source-code/clean-room.py
Or…
We could navigate to the program directory and run it.
# First navigate to the program's directory
cd ./environment/repo/source-code/# Now run the program with its relative path
python ./clean-room.py
Going up a directory
Type the following command.
cd ~/environment/repo/source-code/
From this working directory, how would you get your current working directory to equal /home/
? There are two methods. The first way you could do this is by typing the absolute path.
cd /home/
The second method would be as follows.
cd ../../../../
The double dots mean that you are moving up one directory. Since /home/
sits 4 directories above source-code
, we need to type it four times.
Great! You now have at least a basic grasp on navigation between directories, relative paths, absolute paths, and running programs. We now must cover the other essential command-line skills.
If I asked you to copy the program we just ran to your own file and run it, how would you approach this? Would you open up my program, right-click, copy, and then create a new file and paste the code in? This would certainly work, but we can do it quicker via the command line.
# Navigate to the ~/environment/repo/ path with the `cd` command
cd ~/environment/repo/# Create a new directory to store your code in
mkdir my-code
# Navigate to this new directory
cd my-code/# Create another directory
mkdir program# Navigate to this new directory
cd program/
# Create a new file
touch clean-room.py
# Copy the contents of the source file to your new file
cp ~/environment/repo/source-code/clean-room.py ./clean-room.py
# Run your program
python ./clean-room.py
In this snippet, we learned three new commands, all of which you will use frequently.
The mkdir
command will create a new directory with a name of your choice. You just need to pass an argument to the command which represents the path of the directory that you want to create.
In our first example, we passed in the argument my-code
. Since we didn’t specify a path here, the Bash shell will assume we are referring to the current working directory. We could have also typed EITHER of the following commands to create this new directory:
mkdir ./my-code/# ORmkdir ~/environment/repo/my-code/# ORmkdir /home/ubuntu/environment/repo/my-code/
The touch
command will create a file with a name of your choice. Similar to the mkdir
command, it requires you to pass it an argument that represents the path of the file you want to create. See the explanation for mkdir
above.
The cp
command will “copy” the contents of one file to another, and instead of 1 argument, it takes 2 arguments. First, you need to provide this command with the path to the file that you want to copy the contents of. Second, you need to provide the command the path to the file that you want to “paste” the contents to.
In our example, we wanted to copy the contents of the clean-room.py
file that came with the repository you downloaded earlier, and paste the contents into the brand new file that you just created.
What are arguments?
In the above three commands, I introduced something called an argument. In coding languages, you will often see functions (more on this later) that accept these arguments as inputs.
This entire time, we have actually been using functions! We can’t see much about them, but the cd
, ls
, mkdir
, touch
, and cp
commands are just functions! As functions, they take arguments, which are separated by spaces in the terminal.
In addition, these commands/functions take options. These options are also separated by a space and indicated by the —
character. Remember when we passed in the -la
options to the ls
command to get a more verbose ouput? This was an example of passing options to our functions/commands.
Moving on…
Let’s say you no longer wanted to have this file sitting in the folder you just created. Run the following commands to move the file up one directory and delete the old directory.
# Navigate to the directory where the file is saved
cd ~/environment/repo/my-code/program/ # Move the file up one directory
mv clean-room.py ../ # Move up one directory to where the file has moved to
cd ../# Delete the old directory that now has zero files in it
rm -rf program/
Let’s review. In the above snippet, we used the cd
, mv
, and rm
command. We already know the cd
command, the mv
command is exactly the same as the cp
command (think of this as Cut/Paste rather than Copy/Paste), but we have not yet used the rm
command.
All I have to say is BE CAREFUL with the rm -rf
command.
By passing in the -rf
options, you are instructing the computer to delete a directory and all the files in it. It can be dangerous if you are not careful about which directory you delete.
If you ran something like rm -rf /
, you would be deleting everything on your computer!!! There is no undo button for this kind of mistake.
Finally, let’s say you are done with this program and want to delete it altogether. Navigate to the directory it is in, and then run the rm
command.
cd ~/environment/repo/my-code/
rm clean-room.py
Without the -rf
options, the rm
command is used to delete single files, and all you have to do is provide it with the path of the file you want to delete as an argument.
Recap — There are far more commands you can run on the command line, and during this tutorial, we only covered those that can be run on Mac and Linux. Windows will be a little different, so if you know that you will be developing on Windows, be sure to learn the equivalents of the commands shown above for your machine, or just use the Bash shell for Windows 10 and above.
The commands we covered are all essential to coding and are listed below:
cd
pwd
ls
mkdir
touch
cp
mv
rm
If you need help using these commands, you can always run man <command>
in your terminal, or type “How to use <command>” into Google. As an example, typing man cp
into your terminal will print a manual page for this command.
CP(1) BSD General Commands Manual CP(1)
NAME
cp -- copy files
SYNOPSIS
cp [-R [-H | -L | -P]] [-fi | -n] [-apvX] source_file target_file
cp [-R [-H | -L | -P]] [-fi | -n] [-apvX] source_file ...
target_directory
DESCRIPTION
In the first synopsis form, the cp utility copies the contents of the
source_file to the target_file. In the second synopsis form, the con-
tents of each named source_file is copied to the destination
target_directory. The names of the files themselves are not changed. If
cp detects an attempt to copy a file to itself, the copy will fail.
The following options are available:
-a Same as -pPR options. Preserves structure and attributes of files
but not directory structure.
-f If the destination file cannot be opened, remove it and create a
:
Reading “Man Pages” as they are called is sometimes a confusing endeavor — hence why I saved this for last. When you are just starting out, these may look like a foreign language to you, but if you can spend some time getting used to them, you will thank yourself down the road! As many a programmer might say, RTFM.
Variables
Now that you have a basic understanding of how to use the terminal and run your program, let’s dig into the code itself. Again, do not become discouraged by the code. I have purposefully made it a bit more challenging than most “learn to code” tutorials because I believe the unity of an entire program will help tie the concepts we cover together in the long run.
In your Cloud9 workspace, open the clean-room.py
file.
The first concept we need to cover is that of variables. You can think of a variable as a container for different types of data. In the clean-room.py
program, there are many variables scattered throughout, but by the end of this section, you should be able to recognize them.
Before we get too far into this, I want to mention that the language we are coding in (Python) is a loosely typed language, which means that you do not have to specify the type of variable you are declaring. In languages like C or Java, you would need to signify the type of variable you are declaring. In order to truly understand these variables, we need to do a quick lesson on data types.
Data Types
In programming, there are several data types, and depending on the language there could be more. I chose Python as an introductory language because it avoids some of the more complex data types and reflects the real world more than a language like C does. Present day, most languages that you would find in demand are called high-level languages, which means they are even more abstracted than a language like C. The best way to explain this is through an example. The following Python code is equivalent to the C code after it.
Above — EQUIVALENT TO — below
Would you rather write the first or the second option on a daily basis? Not only does Python require fewer lines of code than C, but the code is simpler.
C is a strongly typed language, which means for every variable we define, we must also tell the GCC compiler what type of variable it is. In this example, we had to define a “struct” (i.e. “object”) that has two data members, both of type “string”. We then had to define an array of the struct type and individually assign values to that array. If none of this makes sense, just trust me when I say Python is easier to write than C.
In the C programming language, we need to know about data types such as char, unsigned char, short, int, bool, float, double, long double, void, and more. In the Python programming language, all of these data types still exist, but unlike C, we as programmers do not need to worry about them. We can dynamically assign and reassign any type of data to a variable. Below is an example of this in Python.
As you can see, we can create complex data structures without having to define their data types beforehand. So what are these data types we are talking about? You probably have started to catch on already, but there are 5 main data types that you need to understand.
- String
- Integer
- Boolean
- Object
- Array
You will be using these data types for at least 95% of your coding needs. Here is an example of each in Python with explanations in the form of comments.
Although you will have many questions regarding these data types, what I have shown are the basics. We are now fully equipped to return to our discussion on variables. As you may have noticed, we are assigning all of this data with an equals sign. To the left of the equals sign is called the “variable” and to the right is the data. In our clean-room.py
program, we have 5 main variables. First, we have name_of_this_program
variable, which is assigned a string value. Second, we have item1
, item2
, and item3
, which are all assigned object values (with string property values). Finally, we have items_in_room
, which is an array of objects.
Defining a variable is simple in Python. The only requirement is that the variable be a single phrase. Below are examples of how to declare a variable and how not to.
# These are valid variable declarations
my_variable = 200
myVariable = 200
MYVARIABLE = 200
MyVariable = 200
# These are invalid variable declarations
my variable = 200
"my variable" = 200
Different languages will have syntax standards. For example, in Python, you would probably define your variables in underscores. This means that each word is separated by an underscore. For example, you could write:
my_custom_variable = 10
When I say “syntax”, I am referring to how your code looks. Many languages will have syntax standards that define how you should write different types of variables, functions, classes, etc. These standards are not mandatory for making your code work, but are considered “best practice” and will make things easier to read for other programmers.
Finally, you might notice that across ALL languages, a fully uppercase variable is considered a constant. In other words, defining a fully uppercase variable tells other programmers that this variable is set once and will never be modified throughout the program.
MYVARIABLE = 200
Loops
Loops are one of the most fundamental concepts in programming. In the real world, there are tons of data floating around, and it can all be structured in a way that we can loop through it.
Take a practical example like a Twitter feed. Some users have thousands of tweets on their account, and it would be impractical to manually scroll through each of them to find a certain word or phrase. If I wanted to loop through an account’s tweets and count the number of external hyperlinks, it would take me days to do manually.
With Python, I could retrieve all the tweets via an API request, loop through all the tweets, and perform an if-then statement to determine whether the current tweet has a link in it. If it does have a link, I would then increment a counter. Below the quick tip, there is some pseudocode that details this logic I explained. Remember, pseudocode is not real code, but it allows us to map out the logic we need to write actual code.
Quick Tip: An API is an “application programming interface”. You do not need to understand this yet. Just know that there are tons of APIs out there, and they are what connect applications on the web. For example, if I was building myself a website and I wanted to sell something, I might need to enable Paypal on my site. To do this, I have two options. First, I could use one of the Paypal buttons that is preconfigured to work in HTML. Second, I could get more advanced and connect to the Paypal API. Once connected to the Paypal API, I could write whatever code I want to enable payments on my site. While putting the button on my site and avoiding the API works, with the API, I could customize my options more.
number_of_links = 0
for each tweet in all_tweets:
if tweet has hyperlink:
number_of_links = number_of_links + 1
print(number_of_links)
Rather than me spending my entire day manually counting tweets, I can write this program in a few minutes and count them in a few seconds. This is the power of loops.
In our clean-room.py
program, we are looping through a small array of three items. In Python, the syntax is:
for item in items_in_room:
# Print the item
print(item)
In other languages, this loop may look a little different but will have the same basic functionality. See below for this same loop in javascript.
items_in_room.forEach((item) => {
console.log(item);
});
You could also do it like this in javascript.
for (let i = 0; i < items_in_room.length; i++){
console.log(items_in_room[i]);
};
Yes, the syntax is a little different in all three loops, but they all achieve the same thing. Even a year down the road, you will find yourself constantly looping through large sets of data and manipulating or extracting something from each individual piece of data.
If-Then Statements
An if-then statement is something anyone can relate to. As in our clean-room.py
program, we are asking ourselves whether each item is a piece of clothing or a piece of trash and then doing something different based on that piece of information. If it is a piece of clothing, we fold and put it away, and if it is a piece of trash, we throw it away. A very common coding pattern is to set up a loop and then perform an if-then statement on each item in the loop.
If-then statements can also be used for more ad-hoc purposes. In the example below, we are setting up an if-then statement to control the amount of logging we do within our program.
# At the top of the file, we create a single variable that we can
# set to true to enable "debug" mode
# or to false to disable "debug" mode debug = True
my_array = [104, 32, 63]
for item in my_array:
if debug:
print("Original value: " + str(item) + " New value: " + str(item * 2))
else:
print(item * 2)
In this example, if we are in debug mode, the program will print the following output.
Original value: 104 New value: 208
Original value: 32 New value: 64
Original value: 63 New value: 126
If we are not in debug mode, the program will print a much simpler output.
208
64
126
Although this is a simple program, if we had something more complex, it might be nice to have this kind of “switch” to go between a more verbose output and a simplified output.
Operators
In the previous two sections, we saw how an if-then statement compares the current item value to an arbitrary value. To do this, the program is using an “operator”. An operator is something we use to compare or modify two pieces of information. Operators will look different in various languages, but all languages have a standard set of operators. Below are the most common operators you will use.
- add
- subtract
- multiply
- divide
- modulus
- increment
- decrement
- greater than
- less than
- equal to
- and
- or
- not
Operators are the one area that I feel Python is a bit confusing in. Although Python is supposed to be intuitive, I think that it adds confusion to the subject since almost all other programming languages use the same set of operator symbols. For example, if I wanted to compare the value of two variables in Python, I would do it like this.
var1 = 100
var2 = 150
if var1 is var2:
print("They are equal!")
if var1 is not var2:
print("They are not equal")
Compare this to the equivalent operation in javascript and you will see the difference.
let var1 = 100
let var2 = 150
if (var1 === var2) {
console.log("They are equal!");
}
if (var1 !== var2) {
console.log("They are not equal");
}
As you can see, the “equal to” operator and “not equal to” operator in Python is not the same as in javascript. In Python, the “equal to” operator can be represented byis
while in javascript it is represented by===
. In Python, the “not equal to” operator is is not
while in javascript it is !==
.
Despite the differences, you need to remember that no matter what language you code in, you will always have the same operators available (although maybe in a slightly different form). Let’s take a look at all the things we can do in Python with operators. If you go to your Cloud9 terminal and type python
, you will enter a Python shell where you can type these commands and follow along. Below is a screenshot of me entering the Python shell in Cloud9.

Below are all the operators that you will use in Python. Type each of them into the Python shell to see what happens!
# Math operators
2 + 2
5 - 3
4 * 8
9 / 3
8 % 4
# Comparison operators - if they evaluate to true, they will print True, if not, they will print False
2 is 2
2 is not 5
# Comparison operators - python also allows the traditional operators used in most languages.
# These are the same operators as the ones used above
2 == 2
2 != 5
# Comparison operators - all the rest
2 > 1
2 >= 2
6 < 7
6 <= 7
2 <> 5 # another way to express "not equal"
# Other operators
2 == 2 and 3 == 3
2 == 2 or 3 == 5
# Increment and decrement
my_var = 2
print(my_var) # 2
my_var += 1
print(my_var) # 3
my_var -= 1
print(my_var) # 2
Knowing all of the operators we have available to us, we could re-write our original if-then statement in the clean-room.py
program multiple ways.
You can see how there are multiple ways to write code! You will find later on that writing working code is the easy part. Writing clean, well-written, working code is the hard part.
Functions
The final concept you need to understand is functions. The simplest way to understand a function is in terms of inputs and outputs. You put something into the function, and you get something different out. In our clean-room.py
program, our function looks like this.
We “define” the function with the def
keyword, and specify that the function will take an input (also called an “argument” as we talked about earlier in this post) called the items_array
. The function will then loop through the items_array
, and based on whether the item is a piece of clothing or piece of trash, it will print a different sentence. A simpler function might look like so:
def add_two_numbers(first_number, second_number):
return first_number + second_number
This function will take two numbers as inputs and return a single output which is the sum of these numbers.
But how do we use these functions? In order to use a function, we must “call” it. This is the same regardless of what language you are programming in. In Python, we can call the add_two_numbers
function like so:
add_two_numbers(1, 1)
There is still a problem though. In our sort_clothes
function, we can call it and it will print something to the terminal. With this function, when we call it, nothing seems to happen. This is because it is returning a value. We need to either store this value in a variable and then print the variable, or print the function directly. We can print the sum of the two numbers to the terminal like so:
Both of these methods will print the number 2 to the terminal. As with our clothes sorting function, some functions do not return a value. If the function does not return a value, then you cannot assign it to a variable.
And that concludes the basic elements of code! No matter what language you write in, you will deal with variables, operators, if-then statements, data types, loops, and functions. They may show up in a slightly different form, but you will see them in any programming language.
Next up, we need to talk about one of the most essential skills you can have as a programmer.
Git
Using Git is not actually considered coding by most peoples’ standards, but it is so commonly used that I consider it an essential building block of coding.
Before we git into the details (yep, programmers are hilarious too), we need to understand the reason why Git is such a popular software. The reason we use Git is that it acts as an advanced “undo button”.
By using Git, hundreds of coders can work on the same project at a time. Every change that is made to the project will be cataloged with the name of the engineer that made the change, and at any point, any engineer can revert back to some previous state of the project.
Let’s go back to the example of building a video transcription software in Python. Imagine that one day, you open your computer, pull down the latest changes to the project, and find out that someone has deleted all your files!!! Without git, you better hope that you had saved a local copy of the project, otherwise, you are out of luck. With git, the fix is very simple. You would simply run the following commands.
# This command will print all of the past changes to the project
git log --oneline
# Example output from the command above might look like:
# 6fda0da I broke the project in this commit!
# f2f170b Some routine bug fix
# 6d54702 Add login functionality
git checkout f2f170b
What I have just done is found the state of the project before my colleague deleted my files and reverted my version of the project to that version. I have essentially pressed a big undo button. I can now work from this version, make my changes, and fix the project.
I know this is theoretical and the commands above are rather advanced, but it demonstrates the power of Git. For our learning purposes, I am only going to teach you the most basic and essential git concepts. You will need to understand the following.
- How to create or connect to a Git repository
- How to commit local changes
- How to push changes to a repository
- How to pull changes from a repository
Concept 1: Setting up a new Repository
First and foremost, you need to understand the difference between a remote and local repository. Every time someone says “remote repository”, this is referring to the Git repository somewhere outside of your computer. Think of some remote village in the middle of nowhere.
Imagine that your code project is sitting in a little house in the remote village, and the only way you can update the code is by connecting via a hyperlink and a password. Now things get a bit confusing when I say “local” repository because local could mean a lot of things. In most cases, the local repository is simply the group of folders and files that are stored on your physical laptop.
In our case, we are considering our “local repository” to be the Cloud9 server that we are coding on. For simplicity, imagine that the Cloud9 server we are using is sitting right next to you and is local. The entire idea behind git is to push and pull changes to and from the local and remote repositories.
We are now going to go through an exercise that will expose you to the basic concepts of Git. At this point, you need to open a new browser. In the first tab, open the repository on your Github account. This is the repository that you “forked” (i.e. copied) from me. At the top-left of your screen, you will see something similar to the screenshot below. In the screenshot below, I have “forked” the Visual Studio Code repository from Microsoft as an example.

Once you are on this page, flip back to your Cloud9 workspace that we set up.
To be clear, the remote repository is the Github browser tab, and your local repository is the one in your Cloud9 browser tab.
Concept 2: Making Changes Locally and Committing them
I am assuming at this point you have made at least one change to your local repository, but just in case, we are going to create a new file with our command-line skills. Open the Cloud9 tab, go down to the terminal, and type the following command.
cd ~/environment/repo/
touch learn-git.txt
You have just created a new file at the “root” of your repository called learn-git.txt
. Double click that file to open it, and type anything into the file and save. At this point, type the following two commands.
git remote -v
git status
You’ll see something like this:

By typing git remote -v
, we are printing the URL to our remote repository (i.e. the one sitting on Github’s servers). By typing git status
, we are seeing what the Git software is aware of on our local machine.
You will probably see more than just the learn-git.txt
file, but as you can see, git is telling us that the learn-git.txt
file is “untracked”. We want this file to be tracked by git, so let's run the following command.
git add learn-git.txt
# We could also run the following command to add ALL files
git add .
By running git add learn-git.txt
, we are telling Git to add just the file we created. You’ll see the following output.

We also might have other files that are untracked, so we can run git add .
to add everything at once. I use git add .
frequently with my projects.
Quick Tip: Although it may not be obvious, you will find that a .
is used to refer to the entire current directory. With coding, you will see that the .
is a multidimensional symbol. We can use it to access the properties of an object (i.e. my_object.property1
), we can use it to refer to the current directory (i.e. cd .
), and we can use it to refer to all the files in the current working directory as we did here.
We can now make our first “commit”, which you can think of as a formal declaration that you are making a change to the project. With each commit, it is advisable that you sign off on the commit with the -s
flag, and you add a message to describe your change with the -m
flag. See the structure of this command below.
git commit -s -m "Add my files to the remote repository on Github!"
You’ll get the following:

Quick Tip: If you want to get rid of the big message that was displayed after committing your files, you will have to run the following two commands in the terminal as an initial setup
git config --global user.name "Your Name"
git config --global user.email you@example.com
There is only one more step here. At this moment, all of your changes have been recorded and are recognized by the Git program, but if you go over to your Github repository right now, you will not see the files that you just added.
To add them, we need to tell Git to push the changes we just “committed” from our local repository to our remote repository. When we are moving data from local to remote, this is called a “push”.
Concept 3: Pushing Changes from Local to Remote
git push origin master

Since we haven’t saved any credentials into our system, we will need to type in our Github username and password before the operation will complete successfully.
This command will push all your changes to the “master branch” of the remote (it is referred to as “origin”) repository. Do not worry about understanding branches at this moment. If you navigate to your Github tab, you will now see the files!
Concept 4: Pulling Changes from Remote to Local
There is only one more thing that we need to understand about Git. We need to understand how to pull changes from the remote repository down to your local repository. This is common when multiple people are working on the same project. Imagine that you do work from 8am — 5pm one day, and your colleague does some work from 5pm — 9pm. When you log in the next morning, your local repository will be different than the remote repository and will not have all of the changes your colleague has made yet. Before you start working, you need to pull your colleague’s changes down to your local repository.
To do this, open up your Github tab. Find the button that says “Create new file” and click it.

Name the file test-file.txt
, add some text to it, and go to the bottom of the screen and press the “Commit new file” button.


You have just edited your remote repository! Now return to your Cloud9 workspace. Notice how your test-file.txt
is not there.
To pull down changes, run the following command.
git pull origin master

After running this command, you will now see test-file.txt
in the file pane to the left!
I know this brief introduction to Git may have been intimidating, but Git is an essential and powerful tool to know about and use. If you want to take your skills further, I have a tutorial that explains everything in more detail.
Although there are complex functions built into git, the basic process is as follows.
- Make local changes
- Commit local changes
- Push local commit to remote repository
- Go to bed.
- Wake up.
- Pull remote changes
- Repeat
Although you will surely run into issues in between these steps, this is the basic flow that you will use for the rest of your coding career!
What is a Coding Environment?
In the previous section, we looked briefly at code in Cloud 9 which is called an IDE, or “Integrated Development Environment”. This IDE made things easy for us because the GCC compiler was already installed, and the Python interpreter was already installed. Fortunately and unfortunately, there are three main operating systems out in the wild.
- Linux
- Mac
- Windows
All three of these operating systems run differently (although Mac and Linux are very similar), and use different compilers/assemblers to run code.
Go Deeper: Watch my Operating Systems Comparison/History Video
What does this mean for you? Not a whole lot. What does it mean for me? It means that if I wanted to teach you how to code on your local machine, I would need to create three separate tutorials! Nevertheless, it is still helpful to understand the differences between them and their coding environments.
Local Environment
You hear it all the time–local development, but what does it mean?
A “local” environment simply means that you are using that physical machine sitting 2 feet in front of you for all your coding needs. When you are coding locally, you do not need an internet connection to run your programs.
There are exceptions to this, but let’s not confuse ourselves. You sometimes need to access the internet to connect to a database, download coding packages, or push/pull to and from Github. For example, if we were trying to go through the Git tutorial in the previous section when we tried to git pull
or git push
, you would not be able to without an internet connection.
The local development environment is also one of the more difficult environments to setup if you are a beginner because it requires you to download software packages to certain locations on your filesystem and troubleshoot issues regarding these downloads.
Hosted/VPS Environment
Believe it or not, Cloud9 is actually a virtual private server running behind the curtains on Amazon Web Services. The user interface (UI) is very simple to use, but beneath the surface, you are actually reading and writing files from some computer sitting in a dark, cold room in some city near you (wherever Amazon’s data centers are). Luckily, all the hard work that goes into setting up such a machine has been done and you can get right to work!
In the future, you may need to use a virtual private server to host an application, run compute-intensive operations, or maybe even as a personal device if you are savvy enough. For now, I would not worry about understanding this. Future tutorials will take you through the complexities (there are lots of them!) related to a VPS.
Virtual Machine/Containerized Environment
These environments are a bit more difficult to understand for a beginner, but I wanted to make you aware of their existence. Until you have spent hours and hours struggling to get your environments set up correctly, you will not appreciate the power of these.
That said, a virtual machine is simply a computer running inside another computer. Why is this helpful? It is helpful because that computer running inside your physical computer can have an entirely different environment setup than your physical computer.
Again, why is this helpful? When you are working on a coding project with multiple people, it is difficult to get everyone on the same page. For example, say you are working on a Python utility that transcribes videos. You might expect this to take several months and several developers to complete. Not only is the project a lofty task, but all of your developers need to have the same version of Python downloaded, the same Python dependencies downloaded, the same versions of these dependencies, and every time something is updated, all the developers must perform the same update. Wouldn’t it be nice if you could set up one computer, clone that computer, and distribute it to all the developers at once? That’s what a virtual machine is.
I debated whether to bring up the topic of “containerization”, but it is too important to leave out. Down the road, you will surely run into something called Docker. Without getting into too much detail, Docker is a container-based utility that acts very similar to a virtual machine but is quicker, less memory intensive, and more agile.
Again, do not spend too much time trying to understand virtualization and containerization. At this stage, it is not important to understand these, but it is important that you are aware that they exist.
Types of Coding
We are almost to the end! I wanted to quickly describe some of the common types of coding that you will see and how they all relate to the concepts you have just learned. I have split the types of coding into three buckets.
- Web / Application Developer
- Networking Engineer / Systems Engineer / Security Engineer
- Data Scientist / AI / Deep Learning
- Other
Rather than trying to explain the nuances between each of these engineers, I have given an example project that each might have built. I have often found that trying to explain the differences between types of coding and coding languages to a new programmer is not effective, so hopefully, visual representations will help! If you have further questions, I suggest Googling each.
Web / App Developer
Most of the tutorials you find on my blog and YouTube channel fall into this category. Of the listed types of engineers, these are the ones that probably write the most code on a daily basis. They are familiar with many languages (HTML, CSS, Javascript, Python, PHP, Java, Git, etc. etc.).
Examples: Facebook, Slack, Spotify, Twitter, Instagram
Networking Engineer / Systems Engineer / Security Engineer
This is probably the hardest occupation to describe because these professionals do a lot of work that is never acknowledged. A perfect example is Cloud9. We have talked about how it makes our lives much easier because it puts everyone on a pre-configured system.
But who configures the system in the first place? Who connects all of the servers in the data warehouse? Who secures the servers from attacks?
That is the job of the networking/systems/security engineers.
Data Scientist / AI / Deep Learning
These engineers work with giant datasets and quite literally make magic happen. You know those cars that drive themselves (cough Tesla)? These engineers are responsible for writing the code that allows these cars to drive themselves.
In addition, you might find these engineers analyzing large sets of business data to help executives make more informed decisions.
Other
Although I would love to document all of the possible engineers that would write code, I simply do not have time. I believe I have covered the major categories, but there are plenty of other jobs that require you to write code. Furthermore, jobs that historically have not required coders (finance, real-estate, etc.) are now demanding engineers who can write logic into their business processes.
Resources and Next steps
As I promised, below are the resources that I recommend for you to learn how to write code. There are hundreds of other resources that could probably teach you the same thing, but I have only listed the ones that I feel will have the greatest impact (and are free!). Follow the steps below (easier said than done!) and you will learn how to code.
- Read this article. It will give you the big picture and it is quite entertaining.
- Take the online CS50 course (spoiler: this is going to take a while, and it’s not easy!). Although this course gets into computer science topics that are not necessary to writing code in more modern languages like Python, I believe they are important for anyone who codes to understand. This is Harvard’s introductory computer science course and it is absolutely free.
- Start building — This is by far the hardest step. I cannot tell you what to build or what type of engineer to become. You must search and search and search some more. Whatever you choose, the most important thing is to just START. Apply for a job. Build an app. Contribute to an open-source project. Teach your friends how to code. Participate in a meetup. Go to a hackathon (my personal favorite way to learn). Doing any of these will get the wheels turning and allow you to see some of the possibilities out there. Although it is tempting to continue taking online courses forever and ever, eventually, you will need to hunker down and build something. It will be hard, so just accept that fact and do it anyway!
Along the way, you will have many many questions. Instead of relying on other people to answer them, you MUST learn how to use Google. I spend more time on Google and StackOverflow reading through error logs and questions than I probably spend actually coding.
To be honest, I do not even have many of the Python commands memorized. To write this tutorial, I had to look up a few things to refresh my memory.
Programming is not about memorizing commands (although some are useful), but rather learning how to Google. Before we part ways, let me give you a real-world example of what I mean. Just a few weeks ago, I was trying to send an email programmatically through my Wordpress site. I had my application all configured, but I had no idea where to start. This is how I solved that problem.
- I went to Google and typed “How to send an email with NodeJS” (NodeJS is a javascript framework that is common among web developers)
- I clicked on this link and found out that there is a software package called “Nodemailer” that will do the job.
- I then went to the “Usage” section of the Nodemailer documentation and learned how to install the Nodemailer software and use it.
- I was not impressed with Nodemailer’s documentation and was not able to figure out how to use the software, so I went back to Google and typed “How to use nodemailer”
- That Google search sent me to this post which helped me solve my problem.
As you can see, programming is not necessarily about how much you know but is about solving problems and looking up information quickly. Don’t be discouraged by all the difficult coding interview questions, because they do not determine your worth as a programmer!
Conclusion
Congratulations on making it to the end of this tutorial! At this point, if your head is not spinning, then you are blessed with exceptional intelligence.
As stated in the beginning, you should not feel the need to fully understand everything that I have mentioned in this post. The goal of this tutorial was to expose you to all the crucial concepts that you will need to eventually understand. Now that you have a basic overview of coding, you can start doing the actual work it takes to teach yourself coding. I wish I could implant my knowledge instantly into your head, but the reality is that you will need to spend hours and hours practicing before this entire tutorial seems like a breeze. That said, the journey of learning how to code is a super exciting one, and you will feel your world opening up the more you learn. Many people suggest learning Spanish, Chinese, or French in school, but the real language you should be fluent in is the language of Code.
Best of luck to you, and feel free to reach out with any questions!