Developers should be practical, not perfectionists

There is barely any time when I can say I learnt a particular skill in college which I use in my daily professional life. Being able to build circuits? Nope. Triple integration? Nope. Calculating poles and zeros of a transfer equation to be able to optimize your circuit? Nope. However, one skill I do use is being practical. As an (electrical) engineer, I learnt to build stuff good enough to function. I learnt to focus more on practical aspect of things rather than purely theoretical. This concept was reinforced when I started my first job as a programmer. It was more important to have a functional code that could be delivered on time than to have the perfect code that took months, if not years, to write. My clients cared about results and budget. This is not to say they didn’t care about quality but they cared about it only to the extent that was necessary. But how do you know what level of quality is good enough?

As a programmer, many times, you will have to decide whether to make your code ‘better’ (and sophisticated) or to leave it in its current functional state. You wrote the code that meets your client’s requirements and everyone’s happy. Do you go the extra mile and make sure all the boundary cases are accounted for? Even the ones that you think have fewer chances of occurring than you winning a million dollar lottery tomorrow? It’s because of such scenarios that I am able to proudly say I am not a perfectionist. I am a practical guy who assesses each situation and determines what level of quality is required. I do not write code that will last for two decades because I know that due to the dynamic nature of the industry I work in, no code will survive that long. Why bother wasting my team and my company’s resources for something that will never be utilized?

As an example, my ex-boss, and my mentor, never asked me to write the perfect code. Instead he taught me little things like to make sure that my code was concise, easy to follow and documented so that the next developer who works on this code can understand the code easily. Years later, I still make sure that my code is simple and documented well to make my successor’s life easy.

Once the disease develops it places cipla cialis generika the individual vulnerable to blindness. viagra cipla 20mg High Intensity Interval Training: High intensity interval training is highly effective way to burn calories, and build lean muscle tissues. Exercises and workouts are not only beneficial for men, but also for women as generic viagra from india they get older. Talking about brick and mortar medical stores, these stores sell quality Get More Information cialis discount online medications at affordable rates but people have to wait for ages for the goods to be delivered. But, still, how do you know what level of quality is sufficient? Many of you will say it’s the level that the client requires. But what if you are your own client? In that scenario, you have to make the decision but then you risk being biased. Perhaps you think you met all the requirements but in reality you are just lazy or really bad at deciding the right level of quality. I don’t have the ‘correct’ answer for what is the right level of quality. At the end of the day, you will have to make that decision and I think that’s a key feature that differentiates good programmers from bad programmers.

I have seen many scenarios where developers deliver a piece of code that adequately meets client’s requirements but requires a complete overhaul when the client returns a month later with an additional requirement. A good developer knows to anticipate these additional requirements and will program his code with them in mind. He won’t necessarily include them in the first draft but will make sure his code is flexible enough to accommodate these changes when needed.

I remember working on writing a function for my client to use to access some data. It was a simple task and the client only needed to pass two arguments to the function. Instead of hard coding those two parameters, my ex-boss advised me to pass in a dictionary instead. I was confused and asked him why that was better. He said it made my code flexible and consistent. If the client decided tomorrow that he would like to pass another argument, all he had to do was add that to the existing dictionary. It required minimal change to both his code and my code. It also meant that all our client facing functions took the same argument – a dictionary!

To wrap it up, a good programmer needs to be practical and not a perfectionist. A good programmer knows to write code of just the right level of quality.