Leveling up as a programmer

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

Content

• Learn the Tools, Frameworks, Programming Languages, and Environments
• Use the Tools, Frameworks, Languages, and Environments
• Learn to read the documentation
• Learn to use Debugging tools and Chrome dev tools
• Learn the basics of Networking
• Learn the basics of testing
• Linux
• Always volunteer for the hard tasks
• Stay open minded and question everything
• Conclusion

Learn the Tools, Frameworks, Programming Languages, and Environments

This one is pretty obvious, but it’s what you’ll spend most of your early programming career doing. Immerse yourself in all kinds of topics — start with the basics and move on to more advanced software engineering concepts as your knowledge grows. Remember to improve your skills both vertically (deep expertise in one area) and horizontally (broad understanding across related fields). For example, if you’re on the frontend developer path, don’t just learn HTML, CSS, and JavaScript. Also learn enough backend, databases, and design to understand the bigger picture of web development.

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, Languages, and Environments

This will come naturally as you follow the previous advice, but there’s one important thing to remember: Try to produce more than you consume. I’m guilty of not following this advice myself—I still read articles and watch tutorials more than I experiment with code. But the real growth as a programmer comes from building things, not just learning passively. Build anything you can think of, and use online resources for project ideas if you’re stuck. Make time for hands-on coding every day. This is what will help you level up your coding skills, open new doors for employment, and accelerate your developer journey.

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, and it’s not always obvious when you’ve reached a new level. Hopefully, this article gives you some ideas on how to recognize those moments and how to optimize your developer growth. I’d love to dive deeper into each of these topics and explain them technically in future articles — this one is already long enough!

Good luck and have fun on your next quest to advance your programming career and coding skills! ⚔️