UPGRADE YOUR PROGRAMMING SKILL

Software development is hard. And when you don’t have much experience it gets even harder. While every tech company out there needs more skilled developers, you might be just starting off your first full-time job as a developer and wondering how you can step up your game.

You want to grow as a developer, but you just need a little push in the right direction. Or maybe you just want to know if you’re on the right track. This article is a piece of advice to all junior developers that want to grow as a developer.

Mindset
The mindset of a junior developer often is to just make the code work. Working software and good software are considered the same, which is a big mistake.
More experienced developers think about the people who have to work with the code, while most junior developers just think about making it work for the computer.
Martin Fowler nailed it when he said, “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”
Once you think you’re done working on a piece of code, think about the next person that has to work with it.
Take a look at your variable names — are they descriptive? If you need a comment to explain what’s going on, your code probably isn’t that great. Try refactoring it. Think about the next person that has to touch your code. If you’re having this mindset, the quality of your code will increase dramatically.
“If you change the way you look at things, the things you look at change.”
— Wayne Dyer

Knowledge
It isn’t surprising a junior developer doesn’t have the same amount of knowledge as more experienced developers. As a junior developer, you should be looking to close the knowledge gap with the mid-level and senior developers.
Start by learning the fundamentals of software development. There’s no growth without relying on a strong foundation. You need to really get to know the programming language or framework you’re working with. Spend a good amount of time studying and practicing the basics of your field.
The great thing about this is that you can do it on your own and at your own pace. Get to know design patterns and how you can implement them. Start reading up on architecture, performance, security, etc. Fiddle around with automated testing. Just don’t stop learning and getting your hands dirty.
What really helps with this is having a side project that you can use as a sandbox to try new things. If you’re having trouble finding a side project you want to work on, you might want to take a look at this article I’ve written. The problems you’ll run into doing these passion projects will foster yourself to solve problems and grow. If don’t want to work on your own passion projects, you could still decide to contribute to open source.
However, you should keep in mind knowledge isn’t the only thing that’s different between the junior and senior developer — it’s just one of the things. Though, expanding your knowledge never hurt anyone.
“Knowledge has a beginning but no end.” — Geeta Iyengar

Write Simple Code
When it comes to writing code, one of the most common mistakes a junior developer can make is writing fancy code. You can recognize the junior developer by quirky one-liners and making simple things overly complex. This is the junior developer’s way of showing off and letting the other developers know how good they can code. All this does is make your code become more verbose than it needs to be — which leads to an increased risk of bugs.
The thing with code is it should be straightforward, which is hard. And it’s something that junior developers don’t do.

Writing simple code requires thoughtfulness. It requires several rounds of refactoring until the code is just right. As a junior developer you should try to stick with the KISS principle: Keep it simple, stupid.
Another important skill you should try to improve is debugging. Every developer writes code that breaks at some point. That’s no big deal. Most important is you learn from your mistakes and avoid repeating them. This is were your debugging skills come in handy. Once you learn how to debug, you will get a better understanding of what’s going on in the process.

Learn From Other Developers
As a junior developer, there’s a lot you can learn from other developers. It might be interesting for you to see how other developers approach and solve certain problems. While there are a lot of different ways you can learn from other developers, we’ll go over two of them.
Learning from other developers might end up with you going through all merge requests in GitLab and looking at the way the code was designed and structured. Does this differ from how you would approach it? If the answer to this question is “yes,” try to figure out what the thought process behind the solution is. Compare both solutions and understand which approach is more beneficial.
Another great way to learn from another developer is by pair programming. Try to pair up with a more experienced developer that acts as a mentor. You should be in the driver seat and actually typing the code. It’s important you code out loud. This means you have to explain to the other developer why you’re doing the things the way you do them. By coding out loud, the other developer gets to know why you’re doing things in a certain way. This provides a great opportunity for instant feedback.
“We all need people who give us feedback. That’s how we improve.” — Bill Gates

Conclusion
There are a lot of things you can do as a junior developer to become a better developer. First of all, you can start by expanding your knowledge. Get to know the theory behind best practices, architecture, etc. Try to close the knowledge gap with more experienced developers. The day you stop learning is the day that you stop growing.
When it comes to coding, try to keep things as simple as possible. Work on a piece of code with the mindset that other developers have to work with it as well. Learn from other developers by looking at how they approach and solve certain problems. If you have the opportunity to pair up with another developer, do it. It’s a great way to learn new things.
Remember that if you truly want to become a better developer, improvement starts with I.