As a software developer, you’ll make mistakes along the way. It is unavoidable and is part of the process of getting better. So, for this post, I want to narrow in on some beginner software developer mistakes.
Before starting, I want to mention that this is not a list of mistakes to be ashamed of. In fact, I’ve done all of them to some degree when I was starting out. This list of mistakes is to point out common mistakes and hopefully prevent you from making them.
1. Building the Wrong Stuff
Building the wrong things is something early developers tend to do at one point or another. They make assumptions on the requirements and start building based on them. Then partway through they find out their assumptions are incorrect or they finished building and it turns out to be not what the customer wanted. In either case, they usually end up starting over again.
As a takeaway, always make sure you’re clear on what to build. Every time you feel the need to make an assumption, ask questions instead so you don’t need to make an assumption. Sometimes, even the customer themselves don’t know exactly what they want so there is no way you would know.
If this is a topic you’re interested in, I have a post that goes much more in-depth about software requirements.
2. Not Taking Breaks
It is a common misconception that when you’re not coding then you’re not working. However, that’s not the nature of software development. Much of it revolves around thinking. This means it is important for you to have a fresh mind. By not taking breaks, you’re overworking your mind and that leads to lower quality ideas.
3. Wrong Attitude Towards Code Reviews
Many early developers tend to not like code reviews. They view them as more of a time for criticism and nothing more. While that could be the case, it is more often a time where you can learn. You’ll be surprised by how much you can learn from having someone more experienced reviewing your code and vice-versa. Code reviews are part of the process of building great software so, instead of dreading them see it as a learning opportunity.
If this is a topic you’re interested in, I have a post about getting more out of code reviews.
4. Obsessing Over Best Practices
Following best practices is definitely something to strive for. However, many early developers follow best practices unconditionally. They don’t actually understand the reason why something is a best practice. As a result, they do whatever the best practice is but they have no reasons to back it up, which is not so helpful. A best practice is known as one because there is some benefit to it. Knowing the reason why will allow you to be able to transfer that knowledge and be a better developer.
5. Planning for the Unknown
Some early developers don’t plan at all, while others spend way too much time planning. The most important thing is to plan for the now while keeping in mind what might come in the future. The key difference between planning for the unknown and keeping in mind what might come in the future is the underlying assumption that the unknown is part of the requirements. As a result, solutions might become more complicated than it needs to be to account for something that is not necessary at the moment.
The takeaway is simply, YAGNI (you aren’t gonna need it). Plan for what you need at the moment while keeping in mind what could come in the future. Have your software design be expandable to add in those future changes if it does become necessary.
6. Not Googling
Google and Stackoverflow are two of the best friends for a software developer. Without them, many would go through troubleshooting the same problems. Whenever you run into an issue that you don’t know, it’s time to google that issue. Chances are someone else has experienced it and has found a solution. You can save yourself a ton of time and headache by doing a simple google search.
7. Writing Code Without Having a Plan
A common mistake that early developers can make is writing code without a plan. While that might work for a small personal project, it’s not going to cut it in production-level software. The existing production code would already have standards that it follows. If you don’t plan first, you could end up reinventing the wheel or introduce something incompatible with the rest of the code.
I hope this post was helpful to you. If you found this post helpful, share it with others so they can benefit too.
What are some of your beginner mistakes?
To get in touch, follow me on Twitter, leave a comment, or send me an email at steven@brightdevelopers.com.