Committed to the wrong branch!

Photo by Sarah Kilian on Unsplash

"Committed to the wrong branch.", "Created a bug in the production code." are some of the most dreadful mistakes, a junior developer can face. A screwed-up feeling will daunt you when you realize that your code is the reason for the bug in the production.

“Make mistakes. Learn from them. Move on.”, is a famous adage.

Yes, mistakes are accepted, but repeating the same mistake is not accepted. Repeating the same mistake is equal to committing a crime.

As a junior dev, I’ve made so many mistakes and even some crimes sometimes, that I regret I haven’t done or at the least not repeated. I am writing these mistakes as a note to myself, and to many junior devs, to not repeat, and to many students, to learn even before getting into the software industry.

Exactly one year ago, from the time I started to write this article, I joined a Software industry as a software developer intern. I just knew that there was some jargon like front-end, back-end, cloud, etc. But, it was when I came across to see everything right before my eyes. I was given hands-on training on front-end engineering and was asked to have a look at the product and use it. After which I was given the source code and asked to have a look and ask doubts immediately whenever I have one. I had no idea what was happening in the code but still, I hadn’t raised the hand to ask what was going in there. And as you might have guessed, it backfired when I was given some actual tasks in the product to finish. I took more time to finish those tasks than what was actually required.

Mistake #1: “Not agreeing to yourself that you don’t know everything and you can’t figure out everything. Although, not raising your hand for your doubts.”

It actually does not look awkward. Senior dev knows that junior devs will actually struggle in the beginning. It is absolutely okay to clear out your doubts by asking someone. And after some time, everyone would definitely get a grasp over the code. And I too did. So, after getting familiar with the code, everything looked like going great. But, it was when something happened. My first revert of code. I was daunted in the same screwed-up feel.

Mistake #2: “Not testing the code in development.”

"Don't believe your instincts saying that this code you changed will not cause any bug. Make sure to test it completely". I was obsessed with the revert of my code. And it was after, when a streak of mistakes started to occur and it all suddenly started to look hard. As, I was obsessed, and over-thinking on that, it made me to not to work on further tasks.

Mistake #3: “Obsessing about the mistakes done.”

And after some days, I forgot about that incident and started to fall in love with my code. I couldn’t digest when someone tells me to change the code. I believed that my lines of code are good and it required no change. And I didn’t understand why my senior dev was pricking in changing that one variable name and following a good design pattern, etc.

Mistake #4: “Taking criticism in a defensive way. Junior dev want only appreciation in the name of feedback. They don’t want to take actual criticism.”

Then, I understood about code reviews, accepted the changes, took time to learn it, and wrote good code. The more I fell in love with the code, the more I learned about good design patterns. So that I kept on changing a single function of code so many times for achieving a masterpiece code in terms of good design and optimization. But it eventually had an adverse effect on other aspects like not meeting deadlines and not testing properly because of lack of time, which again introduced bugs.

Mistake #5: “Over thinking and over engineering often only lead to more bugs and more breakages.”

So, finally, after taking criticisms, developing myself with those criticisms, writing good code following good design principles, doing good tests, and sending it successfully to production, I was affected by the most common Dunning-Kruger effect. Many of us know what it is. Overestimating yourself. In other words, being overconfident. I started to feel that I was doing so good, that I could take any tasks, finish it perfectly and started to underestimate the tasks and its deadlines. But many times it was proved to be wrong.

Mistake #6: “Thinking that you are smarter and more capable than you are actually.”

I definitely had did more mistakes than this. But these 6 mistakes are the most common and abstract level of mistakes which could be the parent of all other mistakes. These will definitely help you when you know it beforehand. And, you have to understand that these are some good old mistakes that every developer would have definitely done at least once in their software career. What you have to look at is not to repeat those mistakes. That is, not committing a crime.

While these things are some of the most important TO NOT DO things, the other hand has some TO DO things which will help you to stand out in the crowd of your fellow workers

What are your mistakes as a junior dev? Comment down.

Written By, 

Balaji. S.V