Dev Career

 The 10 Habits of an Effective Programmer

February 14, 2022

 The 10 Habits of an Effective Programmer

In this article we will analyze 10 habits of an efficient programmer – for you to apply in your career and improve even more as a programmer!

Habits of an Effective Programmer cover

What’s up programmers, how are you all? Let’s see the habits that make a programmer efficient and also desired by companies!

1 – Play around the command line

This is one of the fears of beginners, dealing with Linux and also the command line

But at one time or another you will have to do some action on the production server and most likely it will be via SSH, which is a remote connection from your machine to a server via command line

Then if this programmer needs to do something more critical without being used to the command line, it can be a huge problem

Something very common is to make a dump (backup) of the database; so that the programmer avoids deleting something he cannot or even the database itself.

You can’t go wrong in these situations, so every effective programmer should know how to get around on the command line.

At least know the main commands and have some autonomy when it comes to Linux

2 – Read the documentation

Documentation is the most reliable source of information a programmer can use.

Above any book or dear Stack Over Flow

If you have questions about some language or framework, first you should try to solve your problem through the documentation.

And also when you start to learn a new technology, the easiest way is also the documentation

There are usually some tutorials, where you even get a quick start with this technology, to understand how it works and the most important details.

So, get in the habit of always checking out the docs of the technologies you are developing some software for!

3 – Communication

Communication has nothing to do with code, that’s obvious

However, it is a very necessary soft skill for a programmer, which can avoid many problems.

For example, code conflicts or even avoid a bigger problem because someone doesn’t know how to use your code and changes it unnecessarily.

So good ideas to improve communication are:

Comment with your team about what you are developing;

Also ask your teammates what they are developing;

Try to find a solution to a more complex problem together;

Discussion of a system’s architecture when starting a project;

Talk about code conventions;

This last point is extremely interesting, imagine that a new dev joins the team, in this team all the software documentation needs to be in English as it is a product for foreign countries

If nobody warns him about it (communication), he can do all his part in Portuguese

Generating a big rework to adapt everything he did in English, bad, right?

These problems happen due to lack of communication, so practice it!

4 – Look for the best tools

Although our work is very focused on code, in one situation or another we need external software so we don’t have to reinvent the wheel.

So a programmer must know the tools that can help him be more productive

Some of them are:

  • VS Code: code editor;
  • Postman: client to debug and develop APIs;
  • Filezilla: client for FTP;
  • Lightshot: software for fast and personalized print screen;
  • MySQL Workbench: software to create database schema and view MySQL databases;
  • ColorZilla: Chrome extension to get color value in hexadecimal;

These are just some of the countless tools you can use to advance your day to day.

If you face a very arduous task to be carried out, surely some tool was created to speed up this process, look for it!

5 – Avoid distractions

It may sound silly, but interruptions destroy your focus, productivity and also hinder you in your creation process, so this is definitely one of the habits of an efficient programmer.

Find a way to keep people from bothering you about unnecessary matters.

And also get into the habit of blocking attention thieves while you work: social networks, cell phone notifications

It may sound crazy now, but you’re going to create software that changes people’s lives or solves their problems.

So think about the consequence of some serious bug or software failure, caused only by a simple distraction

These micro interruptions kill your mindset too, making you tired faster, having to restructure everything again in your mind.

Which can take a few minutes, just to get back to where you were.

Eliminate distractions!

6 – Plan the code before programming

A very common mistake for beginners is to start programming before even analyzing the problems.

Leading to numerous conflicting code situations which prevent it from being developed in a straight line of reasoning.

Having to stop more often than necessary than if you were building a flow or even writing each step of the problem and solution for it on paper

You don’t need to theorize two days on top of an authenticated user check, but get in the habit of analyzing the problem before getting down to business.

You will avoid bugs and also problems that you could have solved with the leadership before, for example in the meeting that originated this task

7 – The name of things

This habit works for anything that has a name in your code, such as: functions, variables, classes, etc.

Never use meaningless or unexplanatory names such as: x, y, value, total

Aim for a description that is both effective and short, such as: totalOfCart, quantityOfItems

And also use the camelCase, as I showed in the examples above, don’t make the whole name in the same case, like: carttotal, itemquantity

These bad examples make the code difficult to be read and maintained

We have to keep in mind that maybe we are not going to change this code anymore, but someone else may

So it needs to understand in a clear and fast way what that function does or what that variable is for

It could also happen that six months from now we need to change this code and what if the names are a fuzz…

8 – Tester’s mind

Never pass a task ahead without testing, and never leave all this work to the tester.

Get in the habit of doing some tests with possible variations of the scope of the task you are performing

This will avoid rework and your work will become more reliable too.

The parameter you can use for this is: first test the “happy” path, which is exactly what was demanded in the task, if it passes you will test some different situations and you will implement more bizarre tests as well

This is exactly what the tester will do, but you already save it from having to test and retest the task.

Besides of course you have to fix that bug

Or even worse, what if the bug goes into production?

It may be that you have to do a hotfix in a hurry, or even no one notices until the end of the day and a customer calls furiously to the company that cannot complete the purchases.

So the lower your rework rate is, the more effective you are.

9 – Eliminate repetitions

Another habit of an efficient programmer is to notice excessive repetitions

When you notice that you are doing a boring and repetitive task daily or even weekly, it’s time to automate it.

Find a way for this task to be performed by the computer and not by you

Example: are you having to email unpaid slips every day?

Create a cron that does this every day for you!

Another situation that can happen is you have to do low-complexity actions that have nothing to do with programming

For example block a user who is doing something wrong in the system

In these cases you must create a tutorial of this process, and delegate it to someone from Customer Success or administrative

It makes no sense for a programmer to do administrative tasks and even more repeatedly

10 – Never stop learning

The last of the habits of an efficient programmer – to close with a flourish – is never stop learning

Every time you acquire new knowledge, it becomes easier to learn others.

So you will increasingly learn faster and increase the range of technologies, thus being able to get jobs in more places.

Another benefit of continuous learning is that you become a problem-solving machine.

For being in contact with programming logic and creating new software to study what you learned

Your reasoning level evolves, and consequently you see solutions to problems faster and more intuitively than other devs who are more rusty

While they are struggling with the same problems or why they have to use a new language/tool

You will already be used to the process and it will be just another normal day in your life.

Notify of

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x