Micro-bug is a name I came up with for the tiny details not working in you application when you are programming. For example if you are not able to get data from an API, this is a bug, but if you are able to get the data but you are only getting the first 50 elements instead of the first 100, this is a micro-bug.
Moreover, a micro-bug is not trivial to fix. It is not as if you are simply going to replace 50 with 100 somewhere in your code and you are done in like 5 seconds (if this is the case, just do it). No, a micro-bug is a tiny miss-functionality that requires serious debugging in order to fix it. For this reason, fixing them is very frustrating.
Also, with micro-bugs you are not at an immediate risk of it cascading into another bug. It will not immediately (if ever) affect another part of the application. They will not immediately pile up and make the application unusable.
Now, here it becomes highly opinionated, but my take is that you should not fix this kind of bugs right away. Similarly to how at an exam you solve the easy tasks first, and the hard ones last. This way you are sure you solve the easy ones and you don`t waste all your time thinking about one stupid hard task.
I think it is more important to move on and finish implementing what you set yourself to implement for that day/task.
I am not saying you should move on and forget about it. Definitely not. You will have to fix your micro-bugs before you are done, else you will pass as a person with a terrible attention to detail. Not good.
Most people will instinctively fear that if they don`t fix the micro-bugs right away and move on, they will eventually forget about them. This is why they waste a lot of time frustrating over a tiny functionality when they could spend their valuable time implementing meaningful functionality/getting closer to the task completion.
The solution is to write down the micro-bugs. Write them down in your TODO list, and when you finished everything else go back and polish all the micro-bugs out of you your fabulous code.
Pro tip: micro-bugs might be very specific so even writing them down might feel like a tedious task, if this is the case use “// TODO:” comments in your code. When you are done, make sure there are no “// TODO:” comments left.
Conclusion
What are the characteristics of micro-bugs:
- tiny miss-functionality
- not trivial to fix
- will not immediately affect another part of the code
How to deal with them:
- Write the down. If easier, mark them using a “// TODO: “ comment somewhere around the area where it happens.
- Continue developing the rest of the application/task.
- Come back to the list of micro-bugs and fix them.
- You are done.
