To be a professional programmer, there’re many things that we’ve to do to be a good one.
In this article, we’ll look at the most basic requirement to be a good programmer, which is being professional.
Being professional is hard. We got to clean up the mess that we leave, and we got to take responsibility for our work.
We got to look out for issues and respond to them.
There are many things that we’ve to look out for.
We can mess up any existing functionality, we can lose any data, and we’ve got to minimize emergencies that may come up.
This way, we can the systems running so that customers can do use the software that we’ve built.
We got to make sure that everything is functioning.
Software is hard to create without bugs, so we got to think and test them out before we work on them.
If there are any imperfections, then they’ve to be fixed.
QA Finds Nothing
The ideal scenario is that QA just finds no issues and we move on.
They are there to catch issues that developers may have missed.
QA will probably find bugs. There are too many cases in any software.
It’s too easy to miss things and hopefully, QA will find those issues before the software is released.
We got to test our stuff to make sure they work.
Ideally, we have comprehensive test coverage so that we don’t have to test ourselves.
To make sure that everything works, we got to test it.
We can design our code so that it’s easy to test. If we do that, then testing wouldn’t be too hard.
Automated QA reduces the burden of manual testing, so we should make sure that we have automated testing.
If we have them, at least we know that we didn’t break anything existing when we worked on the code.
We got to make sure that the software we work on is easy to change.
If we make them hard, then we’ll have problems working on it later.
Too many projects become a mess once people worked on it.
Tasks that used to be quick take longer and longer to complete.
More developers won’t help since the code is so messy that no one can navigate through it.
If they work on it, then it’ll just get messier.
Therefore, we should make sure that our code is flexible and maintainable.
To prove that our software is easy to change, the only way to find out is to make changes to it.
We want changes to be easily made all the time.
Every time we look at a module, we should make small changes to improve its structure.
We keep adjusting the structure to keep it easy to change.
If we have tests, then we shouldn’t be afraid of breaking code.
If we break it, we would know right away.
Tests can be run on a whim so that we can check if we broke anything.
If there are changes we want to make, we wouldn’t be afraid to make them.
We should keep learning on and off the job.
Some employers may provide us with resources to learn, but that’s a bonus.
It’s up to us to learn things and keep our knowledge up to date.
We can definitely learn on our free time.
Even a little bit of time each day can add up to a lot.
The spare time is for learning and having fun during the process.
Know Our Field
Technologies, ideas, disciplines, all have to learn.
Everything is moving at a ferocious pace. So we got to incrementally update our knowledge.
A lot is different, but a lot of things stay the same.
Many things like waterfall development have been pushed aside but we can still learn what it is.
There are things that developers should be knowledgable on at the minimum.
They include things like design patterns, design principles, and some development methods like waterfall and agile.
Also, we should know things like test-driven development, object-oriented development, and how to draw designs on UML diagrams and charts.
Developers should know some minimal items.
Also, we should make our code maintainable and flexible.
Testing our code is also important.