Programmers evolve. There are many evolving phases in the career of a programmer. Many learn in the hard way and many in the smart way. In this article I will share 7 killer tips that differentiates a good Programmer from the average or so called good programmers and help you learn the smart way.
1. Be Patient
Patience is the key asset of a good Programmer. The inexperienced programmers are always in a hurry. The minute they get the requirement, they just dive into coding and build something very fragile.
A good Programmer is a great listener. A Good programmer puts himself/herself in user shoes and ask himself, what are the features I would have expected if I were the user of this application.
A Good Programmer is a patient listener to the user's voice. He/She finds loop holes in the requirement and try to see as much deep as they can see into the future.
2. Ask a lot of cross Questions
A good programmer asks a lot of cross questions given the requirement. The undeniable thing in Software Industry is "Requirement Change". But you need to avoid it as much as you can.
Ans - Buy looking into the future. Asking yourself what might be the other features a user may expect with this application.
Therefore, you need to have a very clear idea about the requirement and even should be able to improvise upon the current requirement to satisfy needs of the user that may come as "Requirement Change".
Requirements at their initial stage are very vague. Therefore, to have a clear idea about it, you need to have many fruitful discussion and cross question sessions with your team/boss, so that everyone has the clear idea about "What to build".
3. Spend lot of time in Design
A good Programmer knows that, if your design is simple, it's very easy to incorporate future changes in your code. But if your design is complex, it can very well be a nightmare to make even a minor change.
A good programmer is well versed with the Design Patterns. Try to fit your requirement with an existing design pattern. If it's doable then you are done. You just have to follow the existing pattern and simply write your code.
If the requirement does not fit to an existing design pattern, you should spend a lot of time in the white board to come up with as flexible design as possible for your classes.
The more flexible your design is, less hardship you are going to face in the future.
4. Do not Hard Code Anything
A good programmer does very little hard coding in their code, that too if it is of utmost importance. Put as much information as possible in your config/properties file.
The information in the config file can be changed at anytime without touching anything in the code. The less you are going to touch your code, the less error prone your code will be.
5. Handle as much Exceptions as possible
A bad programmer catches all exceptions in a single Generic Exception Block. That's a very bad practice. A good programmer explicitly handles each and every exception separately.
So, if your code breaks, you exactly know which exception has occurred and take remedial action only for that particular exception and thus everything is under your control.
If you catch all exceptions in a Generic Exception block, you cannot take proper remedial action for each and every exception and that's a very bad approach.
But there can be situation where you might have to catch an unexpected Exception in a Generic way to avoid breakage of your application by a single user who has provided malicious input to your application and your application is not able to handle them explicitly at run-time.
But even if you have a Generic Exception block, you should handle each and every expected Exception explicitly and the Generic Exception block should be the last block in your Exception hierarchy.
6. Log Everything
A good programmer logs everything. If your application fails, you should be able to find out the exact reason of failure from your logs.
You should log as many details as possible as your code is getting executed. These logs will be your best friend in future. There are many internal/external libraries available in many programming languages which provide very good logging facility. Chose one as per your needs.
7. Write test cases
Last but not the least. This differentiates the good programmer from so called good programmers. A good programmer always writes test cases to test each and every functionality of his/her application.
A good programmer runs all his/her test methods, even if s/he does a slightest modification in her/his code.
There are many test/mock frameworks available with almost all major programming languages. Pick one of your choice and write test cases to test your code and try to get as much code coverage as possible.
Sharing is Caring!
RECOMMENDED POSTS FOR YOU