Programmer Best Practices — Continuous Development

Spread the love

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 how to continuously improve ourselves.

Continuous Learning

In the software development world, things change a lot in quick succession.

However, like with anything else, software development is maturing with the accumulation of knowledge.

Many things that need improvement have improved thanks to decades of knowledge accumulation.

Therefore, learning now shouldn’t be hard work.

We can learn from videos, blogs, conferences, forums, books, and more.

The more we learn, the more useful we are.


Another important thing to do is to practice.

We got to keep our skills sharp and ready.

It’s hard to internalize programming knowledge without practice.

Like with anything else we want to master, we just got to practice it.

There are many things that we can do to practice.

We can do simple programming exercises from LeetCode or Project Euler.

Also, we can build apps and other programs that we want to use.

We can pick some technologies we want to use and write apps with them.

There are lots of things we can do to maintain our skills.


Collaborating with other people is another great way to learn.

We can make a special effort to practice programming with other people.

It’s sometimes more fun than working alone all the time, and we can exchange knowledge easily.


Teaching is also a great way to learn.

If we can teach what we learned, then we know we learned it well.

We can bring people into a group and present what we learned.

Professionals take responsibility for learning people less experienced than them.

They won’t let them go unsupervised.

Know Our Domain

We got to understand the domain of the solutions we’re programming.

This means that we got to know the business requirements well.

Otherwise, we probably build things that don’t create the right results for the users.

For instance, if we’re building a payroll system, then we got to know about income taxes and accounting.

We probably want to read some books on these topics.

It’s bad to code from a specification without knowing if they make sense to the business.

We should know enough about the domain to be able to recognize and challenge specification errors.

Identifying with Customers

We got to know what’s bugging our customers.

Otherwise, we build things that they won’t be happy with, and then we got to do it again.

That’s definitely not ideal.


Programmers should be humble.

Risks are taken in a calculated way based on our confidence.

This means that we should be aware that sometimes we’ll fail.

Risk calculations can be wrong, our abilities may fall short of what’s required.

It means that we should never be arrogant and ridicule others.

Saying No

Sometimes, we just got to say no.

There’s no way that everything can be done nicely and quickly.

Also, there’s no way that many features can be implemented in a short timeline.

It’s just unfortunate that the ideal situation won’t happen.

There are always issues that we run into that slow us down/

Being a Team Player

Team players communicate frequently.

We also keep an eye on our teammates.

It’s not someone that says yes all the time.

People that advocate for the team are team players.


If we have any reservations about our commitments, then we shouldn’t commit to something 100%.

We can only commit to what we know can be done within our timeline.

There are always issues that we run into when writing software and we’ll disappoint people if we promise too much and deliver something less than that.

If there is any uncertainty, then we should communicate that.

If things are looking better, then we can communicate that.

If something is slowing us down, then we should update people on that.

The Cost of Saying Yes

We can’t always say yes to everything.

If we do, we won’t have time to do everything that’s promised.

This means that we’ll be stressed and we never get enough done.

Also, if we rush, then we make mistakes and we deliver something crappy.

The code that we write also probably won’t be the best quality.


We should think twice before saying yes to everything.

There is no way that we can do everything. Otherwise, we’ll have problems because we rush our work.

Also, we should learn and practice to keep our knowledge up to date.

By John Au-Yeung

Web developer specializing in React, Vue, and front end development.

Leave a Reply

Your email address will not be published. Required fields are marked *