Posted by: CompleteITProfessional
Junior developers make mistakes. I’ve made them, I’ve seen others make them. We don’t do it intentionally; it’s just something that happens. Learn what these common mistakes are so you can help to avoid them.
Taking On Too Much
I had a tendency to accept a lot of work when I was new to the industry. I enjoy my job and I thought I was quite efficient at it. I also wanted to help my manager and my team as much as I could. The best way of doing this, I thought, was to say yes to all of the work that was given to me.
This would result in me having more work than what I could handle. It meant I couldn’t get things done as effectively as I would like. It also meant that I couldn’t deliver on what I said I could in the timeframe that was expected. My boss didn’t realise this. They didn’t know that I was overcommitted and that I couldn’t get all of the work done.
It’s a mistake I’ve made and one that I see junior developers do as well. Taking on too much work at the same time is not helpful to anyone. You need to do extra work just to keep up. Your manager thinks everything is going OK so doesn’t offer help. Your team thinks everything is OK so they keep doing their work. In the end, it doesn’t really help anyone.
How to avoid this mistake: Think about the effort required and the impact to your other tasks if you try to get this done in the time needed before you accept. Or, ask your boss to prioritise your tasks.
Not Asking For Help When They Are Stuck
Many times I’ve been stuck when developing code. I’ve had trouble understanding some existing code. I’ve been unsure about some requirements, or not sure about some system interfaces that were in place. What did I do? Did I ask around for help?
No, I just kept working, trying to find a solution. On many occasions I spent hours, even days, trying to get something figured out. In many cases, it was due to my lack of understanding or technical difficulties in getting something working.
What I should have done in this situation is ask someone else for help. I could have asked a team member. I could have asked my manager. There may have been someone in another team who could have helped. Any of these options may have saved me the precious time that I actually spent trying to work it out for myself.
Sure, there are some times where you just need to sit down by yourself and work through an issue. But, if it’s something that’s already known, or has already been encountered, getting assistance from another person is a good option. The time you spend talking to them might be ten or fifteen minutes, or longer, but it sure beats the time you would have spent working it out by yourself.
How to avoid this mistake: Try to recognise if you’re stuck on something and ask others for assistance, or ask if they know who to speak to if they don’t know the answer.
Overestimating Time To Finish Tasks
As a developer, we get asked questions about how long certain tasks can take. We get asked how long modules will take to write, or how long unit testing will take. When we are a junior developer, a common mistake is to under quote the amount that it takes to do the tasks. This is probably the most common mistake that junior developers make. I made it a lot in my first few years.
This point is kind of related to the first one, but it’s more focused on a single task. When we provide an estimate on how long it takes to do something, we often do one of two things:
- Overestimate our own ability
- Underestimate the complexity of the work.
Sometimes we even do both.
We sometimes think we can do things faster than we actually can. We can also not really understand how long some tasks can take, either because they are complex or just plain long tasks. The ability to correctly quote tasks comes with experience. However, it’s still hard. Even some of the most experienced IT professionals are unable to quote something accurately. However, the more experienced you get, the easier it is. A good tip to keep in mind is the ability to under promise and over deliver.
How to avoid this mistake: Put more time into your estimates. Allow a buffer for any overruns. Ask others for input.
Making Assumptions Instead Of Clarifying.
One other common mistake that junior developers make is assuming they know something without actually checking. This can come in many forms. We sometimes assume requirements rather than checking that they are true. We sometimes assume that we’re developing something in the best or most efficient way without checking. We can assume that we don’t need to include an area of a system when we actually do need it.
If you’re not sure about something that needs to be done, clarify it. This should be done before we proceed too far into the task. Spending a few minutes clarifying something can save hours or days later in the process. While your assumption may actually turn out to be correct, it’s good to check first. Even if it does end up being correct, asking can cause the other person to actually think of an answer that they may not have considered previously.
How to avoid this mistake: Check anything you’re not sure about with someone else before proceeding.
Developing Before Analysing
We software developers love to write code. No matter what language we’re specialising in, we all like to churn out lines of code to get a system working. However, we need to know what we’re developing and what needs to be done before we start coding. If we don’t, then we can end up writing the wrong thing, which can cause delays and other problems in the process.
In the waterfall methodology, requirements are analysed and gathered before development begins. In many of the Agile methodologies, the requirements of what to build for each small piece of work are determined before the code is written. It’s done this way because it’s faster and cheaper to make changes earlier in the process than to do it as its being coded.
If you’re doing some development work and there is something you’re not sure about, ask someone about it. If you don’t have clear requirements, there’s a good chance it’s not ready for development yet.
How to avoid this mistake: Clarify what the requirements are before you start developing.
Overcomplicating The Solution
Another common mistake made by us junior developers is that we often overcomplicate the solution that is needed. We’ve learnt all these great concepts in university or practiced them at home, and we want to put them into practice in the workplace. Creating complex software with lots of features may seem like a good idea, but it’s often not a good idea for businesses.
There are a few reasons for this. Complex solutions have complex maintenance. Even if you document the code, it can be hard for future teams to maintain, even if they understand the technology being used. Businesses work on saving money and making money and systems should be as efficient as possible without being complicated. You might think it’s a good idea to add in an elaborate piece of code, because “any good developer should know what it does”, but in the future they may not have good developers. We need to put our pride aside and develop code that helps the business get the job done, and is easy to maintain.
How to avoid this mistake: Think of the long-term benefits and impacts of the code that you develop.
Not Improving Their Skills
IT is a fast changing industry. Trends are moving and new technologies and standards are coming out all the time. As a developer, especially a junior one, we might think that we know all we need to know about our chosen field.
This is not true. We need to keep learning. Technology is changing and we need to keep up.
Companies are often sending their employees on training courses to get skilled in certain areas. This isn’t just so they know how to use a system. It’s so they can learn what they need to do, to be able to their job properly and keep up with the industry. Some developers don’t like going on training and just stick to the skills they’ve learnt in their university course. This might be OK for a few years, but eventually you’ll find that your skills are not up to date and you’ll have trouble keeping and getting jobs. Then, you’ll have no choice but to improve your skills.
How to avoid this mistake: Keep an eye out for training courses and education related to your field, and look to improve your skills where you can.
Well, there’s a list of seven mistakes that junior developers commonly make. I hope it’s helped you and prevents you from making the same mistakes I did!