Leveling up as a programmer

Have you ever had that feeling like you know everything in programming and there is nothing you can't learn? I have. But, have you also had that feeling like you don't know anything and will never be able to learn the more advanced concepts and techniques? I have.

Content

---

In my opinion, the former always comes before the latter. This is the time when I "LEVEL UP 👍". Usually this comes after solving a really tough bug, or you learn a totally new concept which opens one or more doors in your quest for ultimate knowledge. This brings you to a new level of understanding and makes you more senior. It is inevitable to progress as the time goes by, just like it is inevitable to gain experience by slaying monsters in an RPG game.

When you get to that new level, you will of course be the noob, and will feel like you don't deserve it. That is the time when you just need to suck it up and take the time to learn even more. You are basically vulnerable at the start of this new level. Have no fear, you will soon reach the middle of the level where you will spend most of your time until next level up.

Being able to recognize this, embrace it, and prepare for the next level is the key for fast progression. In my opinion, if you are not experiencing this regularly, maybe you are in the wrong company, doing a wrong project, working with wrong people. Wrong is maybe a strong word, but, what I mean here is the project that does not challenge you. The project that does not teach you anything new. Or the project where you are just not assigned to the things that are challenging to you.

Having all of this in mind, what can you do to make sure you are progressing fast enough? There are some things you should master, that will make you level up in their own way and make you more suited for harder tasks, build more trust with your employer and your managers, make you more self-confident, and just in general make you a better programmer.

* Disclaimer: As I am a Self-Taught Frontend Web Developer, the things I will describe here are mostly applicable to this position. But, as those are pretty generic (I plan to jump into these topics more in depth at a later point), they should be applicable to any programming path you choose.

Learn the tools, frameworks, language, environments

This one is pretty obvious and that is what you will mostly do at the start of your career. You want to immerse yourself into all kinds of topics. Usually you should start with the basics and move on to more advanced stuff as your knowledge gets wider and deeper. One thing to keep in mind here is that you should improve your knowledge both vertically and horizontally. This means that, if you have chosen the Frontend Developer path, you should not just learn HTML/CSS and a bit of JavaScript. You should also learn just enough Backend, Databases and Design, to be able to have a wider picture and a better understanding of what needs to be done and why.

Having all of this in mind, you should really spend the time to learn or at least understand how the different tooling (in your chosen language) works. How to set it up, how to modify it, how to use it. You should be able to jump into a new project and detect all the tooling that is used and what is doing what. This has been a pain point for me, and it still is. Maybe I am not the only one who is struggling with this. That is why I am putting it high on the list as I think it is important for beginners to embrace this and learn as much as they can to understand the basics of tooling.

Frameworks are a special kind of knowledge. Usually, if you learn one, you will quickly learn others as well. But, that is not always the case. All of them have some specifics and some things that they do in their own way. You should always try to use them the way they are intended to be used. Spending time to read through their documentation is usually a time well spent. Always be mindful that you are within a certain framework and that there probably is a better or more elegant way of doing things elsewhere.

Which framework to learn? Well, that is a good question. But, one that cannot be answered without working with all of the frameworks for some time (couple of projects, or couple of months). And since nobody got time for that, I believe that it is a safe bet to go with what the community uses and what is popular. However, the mostly used, the most popular framework, does not mean that it is the best or the easiest to use (thank you Benjamin for teaching me this). The point I want to make here is, make sure you know your framework and you know the Pros and Cons of it. It will make you a better programmer.

For the language part of this section, I think it is pretty straightforward. No framework, tutorial, or project will substitute or make learning the basics of your language irrelevant. In fact, you should probably stay away from major frameworks in first couple of years of your quest of becoming the ultimate programmer. You can use them, of course, most projects require them. But, you should be aware that they have a lot of abstractions, a lot of code that just works and gives you what you need. That is why they are so useful and widely used. It has the downside that you don't get to see how all of these problems are solved with the vanilla version of the language. For me, reading their source code does not really help. The way I suggest people learn bare bones programming language is just by trying things out without any framework, or build tools or anything like that. Just you, the editor and the browser.

And now the browser, or the environment where you will run your code. Always be mindful of the environment you are in. For us Frontend Developers it is super important to know where you are and for what browsers you are building. Different browsers have different support for different features. Be mindful of that. On projects, one of the first questions I ask is: "What browser versions do we have to support?". Once you finish first several levels (finish your Junior year or two) you will see how versioning is important. I don't want to tell you how much time I have spent tracing bugs which were caused by incompatible versions of NPM packages. Make sure that you know what environment you are developing in/for and what versions of third party code you are using. This will also help you when you are searching for solutions. The rule of thumb is to try and always be up to date or somewhere close to that with your third party code.

Use the tools, frameworks, language, environments

This one will come naturally while following my suggestions in the previous section. But, there is one important thing I want to note here. Try to produce more than you consume. I am so guilty of not following this advice. I am still reading articles and watching tutorials more than I am experimenting with the code. I started the transformation, and this blog is a prime example of that. I cannot stress enough how much you learn while doing. Build anything you can think of, there are even various different sites out there that give you ideas what you can build to learn and train certain techniques and solve certain problems. Use them if you do not have an idea of what to build. Take or make the time for doing this daily. This will help you the most. It can also open new doors, both for employment and for further learning.

Learn to read the documentation

In programming it is really important to have good documentation. Remember all the abstractions that frameworks are doing, being able to read their documentation is what makes you a better programmer. Knowing which function to use and why, makes you more ready for using that framework. But, reading documentation is not always that straightforward. I know I have struggled with understanding the documentation myself. The only tip I can give you here is to learn the basics of your language of choice. Most of the technical terms used in documentation can be understood if you learn the basics of the language. I figured out that exactly lack of this knowledge was the problem for me. Once I went back and relearned and solidified my knowledge of the basics I was able to start effectively reading the documentation of any language or framework.

Learn to use Debugging tools and Chrome dev tools

One of the biggest improvements in being able to fix bugs is being able to debug and inspect your code. For any web developer out there, being able to use super useful Chrome dev tools (or any other browsers` dev tools) should be high on the priority list. This is one of those things that do not take a lot of time to learn, but have an enormous potential to help you, speed you up, or make you more aware of your code and its implications. I strongly recommend spending time to teach yourself at least the basics of using this super useful tool. The other thing, debugging tools, are strongly correlated with using the Chrome dev tools and can be learned in parallel so look out for that side quest 🧰.

Learn the basics of Networking

I really wish I learned this before even starting as a Web Developer. This is so insanely powerful, yet super simple to understand. Of course, this is a big topic in itself, but the things you need to know as a Web Developer are quite small and isolated. Being able to know and understand what is going on when you try to access any website is making you aware of a whole bunch of potential issues and bugs you could figure out (and maybe even solve) in your project. Not to mention that it is one of the more popular interview questions. Those things are scratching a bit the surface of DevOps, but it is worth to have a wider picture. Spend the time and learn these things, it will make you a better programmer.

Learn the basics of testing

Testing has become a hot topic in recent years, and rightfully so. We all want to ship software without bugs, right? But, no one can write any code without bugs. They are sure to happen, just like night and day. Of course, this topic is also a big one, and becoming a master takes time and practise. You should, however, at least scratch the surface and be aware of what kind of problems it can solve, what can it give you in return, how to be confident with your tests. Writing and thinking about tests does not only make you ship software without bugs, it also makes you write more resilient code. It makes you think twice about your approach to solving the problem. Learning TDD is really helpful, but in my opinion, you should focus on the above things first before you jump into testing. It is an advanced topic and you should have a pretty good understanding of the core language before starting to write tests.

Linux

Since I know a bit of PHP and was doing the backend and server tasks throughout my career, I lacked one essential skill. Linux. One of the most valuable things I learned for my own career is learning how Linux works and how to work with it. It will help you with a lot of stuff, and you can basically use any operating system you want (Mac, any Linux distribution, Windows). You can fix some common server issues, you can understand how servers are connected and lots lots more. Not to mention that it will boost your self-confidence as a Programmer.

Always volunteer for the hard tasks

Always volunteer for the hard tasks and always try to understand as deep as you can the problem you are facing. This is not always easy and not always possible. The need to ship features fast is high on the priority list of any company. One of the most important things that will be asked of you as a programmer, especially when you level up within the career ladder, is being able to ship features fast. But how do you do that, how do you get better at it? Not all of us are super good programmers that can draw up the solution in our head in an instant.

The one way it has always worked for me is to take the time to understand the details. Sometimes you just have to stop, take a deep breath and dive deep into the topic at hand. This is not always easy or even feasible, but it is necessary for your own progress. Being able to dissect the issue into smaller parts takes time. To understand how everything works takes time. It also takes a lot of knowledge to be able to do that (read Debugging skills). But, it is also very powerful. Once you solve the problem you will gain so much experience that you will probably level up right there, right at that moment. Not only that, but it also gives you a perfect opportunity to work with more senior people. It gives you more time with your Team Lead. It gives you an opportunity to show how you work, which is not always so obvious. It gives you an opportunity to show that you actually care about the thing you are building. It can show persistence and resilience and not giving up to solve a bug.

As a junior in this field you should always look for these opportunities. Of course, trying to not dive deeper than you should. With a good team, and a good Team Lead this is really easy and safe thing to do. Some will even assign these kind of issues to you without you even asking for it. Embrace it with both hands and try to learn as much as you can. Take the time to learn as much as you can.

Once you finally solve it, take the time to reflect on it. Fill in any gaps in knowledge you might have. Read up about the topics that are not really clear to you. Ask the same question 10 times if necessary. Make sure you understand it. Because, the thing is, you will most likely face the same problem in the future. But, now, you should be able to take it head on by yourself.

Stay open minded and question everything

This one is especially true when you are solving bugs. Do not trust anyone, or anything, even yourself. Double check the obvious things first. Did you add the correct path? Is the function name correct? Is the ID correct? Is it even being called? Debugging skills and experience can help here a lot.

The last thing you want to do is to be self centric and stubborn. If you are sure about something, give proof of it. Otherwise, prove it. Make sure that the mistake is not there, not in your code. Triple check everything. Even if it is like that, and you think all is good from your side, stay humble. Stay open minded. It could happen that the mistake is not on your side. Do you really want to make your colleague feel miserable or do you want to fix the issue?

I believe that this specific skill defines a team player and one that is hard to work with. It is what companies are looking for. You do not have to be the best programmer in the world, but you have to be a team player. Being open and questioning even your solutions will help you pinpoint the issue faster and fix the issue faster. Not only that, but it will make you a better programmer.

There is always a logical explanation why something is not working. Try the system of elimination. Go one step above, and then one more, and then one more. That is why I am advocating to be aware of Backend, Databases, Servers, etc. You do not have to be an expert, but it helps if you know some basics. At the end of the day, what is important is that the work gets done. And for you personally, it should be that you learned something new today. You acquired a new skill.

Conclusion

Leveling up as a programmer is not always straightforward or easy. It is also not easy to detect that moment when you level up. Hopefully, this article gives you a hint how to recognize it and how to optimize it. I would like to dive deeper into each of these topics and technically explain them, maybe in another article. This one is already pretty long.

Good luck and have fun in your next quest! ⚔️