Silvia the junior here👩🏽💻. When I started to take tasks in my current job I was mostly focused on taking things from the sprint goals, which means that I was focusing my job on helping the team deliver new features that were expected from us 🎯.
Sounds cool right? But, if you are part of a team you may also know that from time to time some bugs will get reported. And I, as a junior did nothing about that, I just waited for the seniors of my team to solve them because...😨 I was scared of them 😨.
In my mind, I thought "if I can barely develop new features, imagine checking and fixing features my fellows did." No way! that can't happen, that won't happen 🙅🏽♀️.
One day a bug was reported and it looked pretty simple, it was more of a UX issue than A BUG, so during the daily, I said that I was going to check it.
And so I did: I checked it and the problem was exactly what I thought so in no time I had a PR ready to be approved and my self-esteem was on cloud nine 🎉🥳.
This was such a breakthrough so after this, I decided that I was going to try and check more bugs, even if they looked scary, difficult, or hard.
And this is one of the best decisions I've ever taken during this last year and I want to share some of the things I've learned from this with the hope that this encourages you to solve more bugs and grow from them 💪.
I was one of those that preferred to do a
print() than to actually debug but...oh that has changed so much.
Breakpoints are now one of my favorite ways to check the code thoroughly. It helps so much just to see the code working line by line🔎, and not only to solve where it's wrong but to actually see how things work.
This has helped me to understand better the language I work with and definitely helped me beyond the present problem because as I understand the way things get done, I can take that into account in all the features I develop.
Also, it helps you save time as it is not the same to change lines of code where you think the problem is, rather than doing it where the problem truly is.
Of course, this newly gotten knowledge help me to solve the bugs smartly. Is not only making something behave as we want but to be sure it won't happen again because my solution proposal is accurate.
The tricky thing about bugs is that the behavior may be erratic 🤔, it may be something that worked out before but not anymore, or that works sometimes.
So while investigating bugs or while trying to fix them more than once we will have to try not one but many solutions and sometimes these will also fail, or it could behave erratically
and that is gold because all those new things you find or you get stuck with are learning points.
This has helped me not to only ask things to my mentor or my colleagues but to ask ✨better questions✨.
Rather than asking why this doesn't work? now I can tell them, I've tried this and that, this doesn't work here, and that behaves weirdly because of whatever. What do you think it may be? Is this the right place? What am I not seeing? Is this normal behavior?
And that is amazing because first of all, for them is easier to help you, and for you, you have learned already a lot while making your own conclusions, and whatever the answer they have for you you will be able to take better advantage.
This was the hardest lesson for me 🥲. Because I want to be able to do things but also...I can't. There are things I don't understand, there are things that I don't know, and...that's ok.
And this is not a junior thing, seniors don't know stuff either, and...that's ok.
The moment I understood that we are all learning no matter our seniority I started to see things differently. Because I stopped to put extra pressure on myself.
What I do when I don't find a solution is to update the bug ticket with my findings 👩🏽💻, with the hope that the next person can use that information and thus make their job easier.
This way I feel that I've helped at least in discarding things or giving new scenarios that may help my colleagues to find a solution.
Yes, this is something we get to know pretty early in our careers. However, when dealing with bugs is so obvious.
But the important thing is not only the realization that there are many ways to develop something but that sometimes, even if you can solve it in many ways, there's a more right way to do so🥇.
The amazing thing about this is that, you now know how to do something in three different ways but also you know what's the best way in certain scenarios, so choosing the best way to approach certain problems is really important and is long-term learning 🧠 that you will take with you.
So in the future, if you or anyone in your team face something similar, you will be able to share your findings to avoid future bugs contributing to better quality code.
I'm probably missing some things but I would love to hear what bugs have taught you so please, tell me in the comments below 👇