The Key to Becoming a Great Software Developer
If you are new to software development, whether starting as a professional or even just learning as a student, you probably find the culture intimidating. The range of skills required to become a “great” developer is vast, with low-level skills that range from a solid sense of mathematics to high-level skills like user-interface design.
It can be overwhelming trying to balance learning all these skills, especially while trying to keep up with the constantly evolving software industry. What can you do to improve your abilities, to get from where you are to where you want to be?
In my 20 years of professional experience, reading books and articles and watching videos is not the important step. The most important thing is…
Practice!
If you are learning how to play an instrument, it’s no question for most people that you can’t get anywhere until you pick up the instrument and try to play it. And it’s not just once in awhile, either. Instrument practice is something most musicians do every day. Even if they are professionals.
Learning theory and exploring new ideas is, obviously, essential to improving yourself in any discipline. The most important step, though, is turning those concepts into engrained knowledge and muscle memory. In this way, programming is a lot like learning an instrument.
Until you burn in those core concepts — and you will need to continue to learn these throughout your career — you will struggle with the basic components of programming, for example:
- How to approach a problem
- How to break it down
- How to test and find bugs
- How to quickly narrow down the likely source of a bug
- How to improve performance and maintainability.
- How Do You Practice to be a great Developer?
On the surface, this seems like a dumb question, but it really isn’t! Practicing an instrument diverges from programming, because you can pick up a piece of music and play that same piece over-and-over until you get better. Programming doesn’t work quite the same way, because once you’ve solved a problem, you can, at best, iterate on that solution to improve it.
That’s an important step, but to really expand your knowledge, you need to regularly find new challenges.
Find Your Own Projects
The best way to learn is to find a problem you want to solve, and try to solve it yourself. Maybe you want to automate something, or calculate some value regularly.
Basically keep your eyes open in your own life for things that you would like to work better, or try to improve on something you already use. Then try to research and see if you can solve it. Don’t get caught up in finding a “perfect” solution, rather see how close you can get in a short amount of time.
These little exercises will keep your mind fresh and have the benefit of having no fixed goal, so you can have fun with them.
Open Source
A common recommendation is to look for Open Source projects you can help on. I definitely recommend digging into the FOSS culture, as it will expose you to a wide and varied set of skills and viewpoints.
Unlike a lot of programmers, I don’t think this works perfectly for someone starting out, simply because jumping into even a small OSS project is overwhelming, as there’s a ton of basic concepts that you are expected to already understand, like code style, language tricks and concepts, and more.
Competitive Programming Sites
My favorite site for daily programming challenges is Codewars. (Disclaimer: I liked it so much, I now work for them.) Codewars is great for honing your developer skills, as it provides new content all the time, in a wide variety of languages, so you can make sure you flex that programming muscle whenever you get the urge.
Make Mistakes Every Day
I think this is the most important step, and the most important skill to learn. You need to make mistakes every day. Every time you practice, practice until you make a mistake. Learn from that mistake.
If you try a new problem and solve it easily, you probably aren’t learning anything new. That is more like reciting a previously learned skill. When you come across a problem you can solve in your head, find a new way to solve that same problem. Don’t even worry if it’s not the best way, just expand your skills with new ideas.
Great Practice Tips
To really accelerate your education, follow these tips:
Break Your Code
A common mistake very early programmers make is to write it, then only run it once or against the most simple scenario. A great way to deepen your abilities is to purposefully try to break your own code.
Find unexpected ways to run your code, test on different machines, disable the internet, etc. Ask yourself:
- Does it still work, or does it just crash? (If it crashes, see the next section.)
- If it runs, does it report errors?
- Can you find a way to handle those errors without stopping the program? As an example, if it fails due to the internet being down, maybe you could try the request again later, and only stop if several requests fail.
Learn How to Debug
This is a deeper topic than can easily be covered here, but every language has some way of debugging. This is another reason why you should make mistakes every day: you want a reason to dive down under the surface of your code and understand what’s happening at a deeper level.
Most debugging will let you step through your program — jumping deeper into the lower layers and learning what really happens when you call a method, or set a value, or make a network request.
The goal with debugging — from a learning standpoint — is to build up that muscle memory about how the parts of a program are glued together. The deeper this knowledge, the easier it will be to predict, find, and fix bugs in the future.
Don’t Ask Questions…
…at least not immediately. Instead, try anything and everything you can think of. This is more important the less comfortable you are with a concept or language.
When you can’t think of anything on your own, search! The Internet is overflowing with help for learning programmers. Find answers and try them out, but don’t just copy-and-paste and move on. Modify those answers, see if you can understand why they work, adopt them to your code.
…But Always Seek Advice
When you have tried everything, and preferably after you have a working solution, now is the best time to seek advice. Look to peers and senior developers to review your code.
Take that advice, apply it and use it in the future. Rewrite what you already did with those suggestions in mind. Ask yourself
Did they help improve the code? If so, how? Did they make it more readable? How can you apply that in the future? Did they improve performance? What assumptions did the old code make that were less performant? Can you expand on that suggestion? Maybe you can apply the changes in similar ways to other parts of your code.
Now, Start Practicing!
Now that you have some ideas, get out there and start practicing! The longer you wait, the longer before you’ll feel confident enough to take the next steps in your developer career.
There’s no time like right now to begin turning that surface knowledge into long-term, deeper skills.
