mogery's Guide to Becoming a Programmer
In my 9-ish years of experience with coding, here are the rules and tips I've found to be most useful for newbies.
1. Choose the Web first, probably
There are a multitude of reasons why choosing to build things on the Web will make your experience with coding much better:
- It starts off very simple. No need to install anything. Just write some text into a file and it shows up on your screen. Easy!
- It's extremely versatile. Personal sites, social media, games, art, and more. The sky's the limit for what you can build on the web.
- It's accessible. People who you show your project to don't need to download or install anything. They just click on a link, and they instantly see whatever you built. And if something goes wrong with your site, you can instantly change the code.
If you have a specific goal in mind, you may choose not to learn Web development, and that is completely fine. You will probably branch out from whatever you learn anyways if you find it boring, (and you totally should if you find it boring, otherwise you will burn out,) and your acquired knowledge will somewhat apply in other areas too.
If you don't end up going with the Web, don't stress out too much about which language you choose! When you learn a language, you learn programming concepts that can be applied to other languages. Variables are essentially the same in 99% of languages. The only difference is the characters you need to type. Do a quick search for "<field of interest> programming language", and get going!
An important exception is game development. If you are interested in that, pick an engine, and learn whatever language it supports. I personally recommend Godot, and its scripting language, GDScript.
The rest of the steps in this guide apply to whatever field or language you choose.
A quick guide to learning the Web
- I personally recommend Visual Studio Code for code editing.
- To learn the basics, use freeCodeCamp.
- To learn how a specific thing works, use MDN.
- You should also learn how Git and GitHub work.
- If you see the words "jQuery" or "W3Schools", run.
Once you've got a grasp on the basics, you can continue to step 2.
2. Fuck around
This is the single most important part of the process. Whenever you have an idea of something you might build, try to build it. By doing this, you will gain a lot of coding muscle memory, and you will get to use programming concepts in practice.
Let's say, you want to build a super simple chatroom website. This might seem like a fairly basic idea, but here are some things that (probably) sound like complete nonsense to you right now, but you (probably) will start to learn from building it:
- Backend development
- How to host a backend
- How to host a frontend
- ...and probably more
This is not an idea recommendation. If you aren't interested in this idea, then don't build it. I guarantee that you won't like building things that you don't care about. Being interested in the results is what is going to pull you through the process of figuring all this stuff out.
The key when trying to build something you want is figuring out what you need to learn to do it. The options for that is either trying to find out on your own, which can be tough and frustrating, or asking people who are more experienced than you. For these sorts of questions, I would stay away from Stack Overflow: its community can be quite harsh and it's more intended for exact problems. Rather, (if you've got no friends who are into programming, or they can't help you,) post in some Reddit communities (e.g. r/learnprogramming), or ask in some Discord servers. A lot of communities are against hand-holding, so be prepared to have to problem-solve on your own. Google (or your preferred search engine) is your best friend.
Once you have enough experience, you can start relying on your preexisting knowledge, instead of asking people every time.
Also, there are no doubts about it: you will make mistakes. Like, a lot of them. It might seem like you're terrible and a fraud, but you need to shut that voice up. Everybody has made mistakes, is making mistakes, and will make mistakes, regardless of skill level.
3. Solve a problem, and ship it
If you've got something that is bothering you, do something about it. Chances are, it's bothering someone else too. When a problem occurs to you, you should consider building a solution, and making it available to everyone.
Sure, this will teach you about Sysadmin, DevOps, deploying, so on and so forth. But it will also teach you about follow-through. It will teach you about driving a project from start to finish, problem-solving, and managing your motivation.
It will also teach you about having a user-base, listening to feedback, and interacting with other developers.
All of these lessons are extremely valuable, and they make you a better programmer.
(NOTE: If you are interested in game development, this step is not about solving a problem, rather finding a game idea that people enjoy.)
4. Dig deeper
Have you ever wondered how the things you're using work? How HTTP, the way you deliver your websites to people works? How that one library that's super useful and you always use works? You can find out!
A great way to learn languages (in the real-world, human sense, not in the programming sense) is to look at how other people speak them. Talking with native speakers, reading books written in the language, watching Netflix in the language, etc. Imagine trying to speak a foreign language without ever hearing a word of it in your life. Sounds like a terrible idea, right? Well, why would you do the same with programming languages?
Reading other people's code not only helps you get better at a certain language, or helps you understand certain concepts that the code deals with, but it also improves a very important, universal programming skill: understanding codebases.
Continuing with the linguistics simile, understanding how a codebase is built is kind-of like understanding how a sentence is built. By reading the code of a library, you begin to understand how all parts of it, all those separate files, methods and classes, link and work together. This is a very important skill to master, and it will not only help you understand the structure of other people's codebases, but it will also help you structure your own projects better.
You can usually find the source code of open-source projects through a simple search online.
Whatever skill you're learning, experience is key. The more you code, the better you get at it. That's just a fact.
You will probably end up building more incomplete or abandoned things than complete products with a blossoming user-base, but that is completely fine. Experimenting is important, and it's fine if people don't find every single project you make to be useful. Build your projects for yourself first.
Eventually, you will get to the point where you will get an idea, you like it, you know how to build it, but you simply won't. You don't have the time, or you think it's less important than whatever you are working on. And at this point, you realise that the times of scraping the barrel for ideas are gone, and figuring out how to build a project is becoming much less painful.
Are you familiar with the Dunning-Kruger effect? It's a cognitive bias that makes people with very little knowledge over-confident. The graph looks somewhat like this:
When you started with fucking around, you probably ended up deep in the Valley of Despair. But over time, you've been learning more and more. And now, congratulations! You've arrived to, I would personally say, about the middle of the Slope of Enlightenment. However, you're not done yet.
Programming is an ever-changing world. Never stop reading. Never stop learning. And most importantly, never stop fucking around.
Additional Notes & Tips
- This guide is written by a 16 year old with little-to-no responsibilities in life. If you are in urgent need of a software development job, I recommend that you look for the technologies needed in job postings around you, and start learning them. Once you're in the right place, you can continue the path laid out in this post, if you'd like.
- If you've started building something, and realized it's all wrong, don't be afraid to throw it out and start over. However, don't do this excessively either: you'll end up getting nothing done. Usually starting over just once should be enough.