How to be a better developer

You won't just become a great developer overnight. It takes time and perseverance. In this article, I will go through 9 concrete points to help you improve and be a better developer. Ultimately, it is up to you, but having some pointers might make the road a bit clearer.

Have a plan - and stick to it (-ish)

One of the most important parts of developing yourself in one direction is actually knowing in what direction you are going. There is a fine line between setting goals that are too easy to achieve and goals that are too difficult. But setting the plan is just the first step. It is really important to be consistent in following the plan. A mentor could help you construct a plan that is realistic and manageable to follow. You provide information about what direction you want to go, what goals you have as a developer, and where you want to end up in some years. A mentor could then help you set up a plan tailored for you and check in on your progress throughout the year.

Circumstances may change, customer requirements may change, and your interest may change when you learn new things. Therefore, occasionally it might be time for a revision of the plan - regardless of how far into the plan you've come. If you ever look at your plan and thinks, "Well, this is not in the direction I think I want to go," you should, as early as possible, make the changes needed to your plan. A mentor can help you realign your plans with your goals. This is also an argument for why plans should not be any longer than six months. It is possible to have a more over-arching end goal, but the plan should have tangible goals for the next few months.

Practice more

When you are sure you're following all the directions of your plan and sticking to it, it's time to practice even more. There is no such thing as practicing too much. When you think you got it, do it even more. Only then does it start to sit almost automatically when you later encounter a similar challenge. For a developer to really excel in their field, practice is unavoidable. You will become a good developer because you will meet similar tasks or challenges you have seen before. So at that point, it should be almost like "muscle memory" to solve each challenge. You will also be better suited to identify challenges and how to divide the bigger task into manageable smaller tasks that you have solved before.

A lot of developers, including myself, get bored when what they are working on is 90% done. But nonetheless: finish what you start! Get your code out in a public repo on GitHub and show what you've been doing. You should also go back and improve the code you've written before. See what assumptions you made wrong, and learn from them. See what choices you made early that resulted in you having to do something over. Learn to see further ahead while programming by looking at earlier mistakes or code you'll have to redo, refactor or change in any way. You will learn to look further ahead when starting a new project when you know what kind of pitfalls may be in the future. You will quickly start to see where your short-term thinking fails you. Don't be afraid of your application or code being crap. That means you have more to come back to and improve on later.

Join a community

Being in a community where you can discuss code, see how others solve similar challenges, and share your knowledge can never be underestimated. If that's a forum, a Discord server, a Workplace group at work or whatever. A place to talk about and discuss development will hugely help you in your quest to become a better developer. Getting other people's views and input will greatly improve your own code. If you start questioning if your solution is the best, you will force yourself to take a deeper dive into the challenges and solutions.

So you should not only join, but you should also participate. Ask questions, challenge (positively, of course), and cheer others. Let people know if they helped you or if you like their solution or way of thinking. Encourage others and help them grow as well. Having a professional network will definitely enable you to grow since everybody has different experiences. You might learn something from a completely different field than what you're currently working within.

Focus on one stack - specialize

There is a saying - "Jack of all trades, master of none", and this holds a lot of truth within development as well. In order to have a deep and solid competence within a stack, you would need to specialize. If you really want to excel as a developer, a master of a trade is definitely something you want to aim for. At least until you feel like you have mastered one stack, there should be no reason to try to learn more than one stack at the a time.

This does not necessarily mean that you have to limit yourself to just C# or one kind of service. Because any stack or ecosystem consists of more than one language and framework. For example, when developing in C# on Azure, there is PowerShell, the portal, you have to know something about infrastructure, it pays off to know something about Kubernetes, etc...Also, learn something about other languages, learn the basics -and write something simple. Just learn how to learn new frameworks, but still keep the focus on mastering your stack. But realize that other languages and frameworks might have features that you can use or take notice of in your own applications and code in your own stack.

Help others

Never underestimate the learning in teaching someone else. They will ask you questions you never thought of yourself. It is also ok to not know the answer. Then be honest and say you don't know it. But also say that you will check it out and give an answer the next time you are teaching - or come back to it later. Teaching will both serve as a great repetition for you, but also make you dig deeper into the ocean of knowledge surrounding your stack. Teaching will let you look at the same problems from a different point of view. By sharing your knowledge, your team will also collectively be better. If you help someone get better faster, the bigger the possibility these people will have something to teach you later as well.

Be open to change and to being wrong

You will be wrong! A lot of times. You might make a bad solution, or you might take the wrong choices when it comes to languages, stack and framework. Also, be open to change because everything will change. Some frameworks will disappear, and some will come. Some languages will be discontinued, and others will arise. Don't be stubborn and resist change. If you resist, your value as a developer will slowly decrease. Be curious about new things and listen to others within the community. Be aware of the difference between hearing and listening. Make a note of what others say, and take it into consideration. Even if you think it sounds wrong or just like a bad idea. Try to understand where they're coming from, why they are telling you this, and try to see if you have a common understanding of the problem. Are your definitions and prerequisites the same? Ensure that you're actually talking about the same thing.

Learn to say no

Help people, but not at the expense of yourself. You still need time to do all the other things above. You must practice, study new information, redo your old code, and build your professional network. Furthermore, you cannot help others if you don't do the things that make you better. Then you will stagnate and not be able to help anymore. Everything moves fast within development, so you are at risk of being "obsolete" if you don't keep yourself updated. You should always focus on what makes you better.

You cannot change the past

Acknowledge that you could probably have done something different earlier, but you cannot change this now. Maybe you could have started programming earlier, maybe you could have chosen another framework when you started, or maybe you should have jumped on that one hype and dropped another. There are countless choices we have all made in the past that cannot be changed now anyway. What we can change is the direction we're setting for the future. Make improvements today to make tomorrow better. I once had a superior who always said, when shit really hit the fan: "Ok, let's focus on what we actually can influence". There are a lot of variables and factors that are out of our hands to change. They are there, and we have to take them into consideration but also acknowledge that it is what it is. And then make plans with all the circumstances taken into consideration. We can only change the future and the direction within the boundaries. Knowing what our changeable variables are is key, and should be our only focus.

Time Framing

When you're struggling with an issue or a problem for a long period of time, the problem itself starts getting impossible. A big problem is that you get stuck in the same thought patterns, and it's hard to release yourself from those and see the task from another view. So whenever you're heading to a hard task or encounters a problem: give yourself a time limit. You will not struggle with the same problem for more than 2 hours. So what to do when the two hours are gone? Well, that depends a bit on your situation and access to other resources. If you have any close peers available, the best thing is simply to ask for help. Then you'll get another set of eyes on the problem. But what if you don't have colleagues or peers within the same field? Try to explain the problem to somebody else, even if they can't help you directly with the code. Just wording the problem and explaining what you are trying to do and what doesn't work, and how you have thought to get there might help you to understand the problem better yourself.

If you are alone and have no one you can ask, you can always rely on Google or Stack Overflow to point you in the correct direction. Or at least take a break and do something else. Acknowledge that you will not get any further right now, and try to take another look at it tomorrow.

You should never be allowed to stare at one problem for more than 2 hours.

Conclusion

You must acknowledge that you will never be a "fully trained "developer. There is always something to learn, skills to improve and new technology to understand. The more you learn, the more you understand how little you know.

But you can maximize your improvements by creating some structure around your work and personal growth. And never underestimate how much you can learn just by teaching someone else.

We all feel a little stupid occasionally, but that's just part of the game - and a sign that you have spotted something you can learn!