10 Habits of Successful Developers

January 6, 2019

Developers coding — Image courtesy: unsplash.com

1. Write clean, reusable code

Software development can sometimes get really troublesome when the code base increases in size. With multiple developers contributing to a repository, the size and the complexity of the code increases exponentially, and the ease of reading and maintaining code decreases.

A clean code helps to communicate ideas and logic to fellow developers in a better way. It also helps to maintain greater efficiency of the software and reduce its chances to be termed legacy in a short time.

A code is more often read than written. It is thus necessary to spend some time in analysing and thinking about an approach before starting to code.

As the code base increases in size, multiple interdependent components start building up that makes code alteration difficult. This is seen in case of any Requirement Changes or Bug fixes. Having a clean and reusable code that is modularised helps a lot in these situations.

A programmer can be well assured that other components of the code won’t break easily if we change a small part of it.

2. Write code that is easier to read and test

Software development usually involves a team effort with multiple minds collaborating on a single code base. It is thus a thumb rule to maintain some guidelines and practices that enable swift development.

Writing code that is easy to read not only helps your fellow developers to understand but also reduces the timeframe of software development by minimising redundancy.

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.
Martin Fowler

How to write readable code:

Good variable, method and class names
Variables, classes and methods that have a single purpose
Consistent indentation and formatting style
Reduction of the nesting level in code

To verify if everything is working as expected, we need to write good test cases to cover all the aspects and behaviour of the code. One cannot trust software unless it is tested and verified to be usable, reliable and secure.

The better the test coverage, the lesser the chances of your software to be vulnerable to changes.

3. Listen more; speak less

A good developer must be a good listener.

Ideas and techniques do not always come from within, but rather, come by observing and understanding from our surroundings.

Listening to different thoughts, ideas, and logic opens up an entire ocean of knowledge in front of you to explore and experiment with.

Spending some time with fellow developers can help brainstorm collaborative ideas and techniques that in turn, will improve development.

4. Get help from or collaborate with strangers on the internet

A good developer will always look for different options to do the same thing. He can evaluate and analyse different solutions on various parameters like efficiency, ease of use, readability, understandability etc.

Don’t reinvent the wheel.

In this world with so many great minds devoting hours into coding, we are assured to find a problem that others might have encountered as well. There are forums where people discuss these problems and try to bring up a collaborative solution.

Getting help from online forums is not a bad thing at all. It gives you more ideas, approaches and different thought processes to the same problem. You also get to know certain variations of the problem in hand.

Getting help online does not necessarily mean copy-pasting from Stack Overflow! It is about researching what the problem could be and how a particular solution actually solves the same.

A simple copy-paste can help you achieve your short-term goal but might be troublesome at a later date when you want to modify it.

5. Be open to new things

The most important skill for a successful software engineer is to know how to acquire new skills.

Every year there are many technologies that make their debut in the market while many others disappear gradually.

Having a fair knowledge of different languages, frameworks, methodologies, algorithms and tools can help one evaluate what will suit their projects best. It also helps one to grow in this competitive and volatile industry.

Highly successful developers and programmers happen to know a variety of these touch points, constantly learning and applying them in diverse situations. They keep themselves updated with the new trends via various sources like blogs, newsletters, forums etc.

6. Be comfortable with being uncomfortable

If you are building the same simple software over and over again, then you are not stretching the boundaries of your skills.

To become a better developer, one must try to get to work on stuff that is difficult and challenging. This confronts an individual to study further about the problem in hand and thus, expand their horizon.

Working on things that are uncomfortable will help you ask many questions about the subject that you wouldn’t have even thought about before. This churns your brain to think about minimising the logic and get a better understanding of the problem in terms of complexity and strategy.

In the end, making this leap will help you to build yourself as a better technical contributor to your team and also to the field of software development.

You can either have an experience of 10 years or have the same experience for 10 years.
Mohit Malpani

There are endless opportunities; we just need the right attitude within us to conquer any goal.

7. Stop trying to prove yourself right

Proving yourself to be right is not the way the software industry works. A good developer often sits back to analyse what may go wrong. A constant question: “How can I make this better and more robust?”

A good test is not that proves your code works right. A good test is one that fails when your code goes wrong.

As a budding stage in software development, many individuals, willing to keep up with the pace in the market, try to prove themselves and their code to be right in all aspects. This attitude settles in a person’s behaviour and generally stands uncorrected.

If you stop to prove yourself right and focus more on what might be wrong, you will be moving towards filling all the gaps and discrepancies that may behold you later.

8. “The code works” isn’t where you stop; it’s where you start

“Oh wow! It works”

Congratulations! You have achieved what you wanted.

Do you want to stop here and sit back or you want to make this work in a better way?

A trait generally found among excellent developers is to make multiple iterations on their code. An average programmer generally quits work immediately when he/she observes positive results.

Good programmers know that the first attempt is just the first attempt; there is more to explore and make things of finer quality.

What developers ask is to make the solution more:

Efficient
Readable
Robust
Modularised
Scalable
Reliable

9. Write code multiple times

Good software is usually written three times.

The first time: to prove a solution is possible (Proof of Concept aka PoC)
The second time: to make it work
The third time: to make it work in the right way

Writing a code multiple times makes you think and help fill multiple potholes where the code might have gone wrong.

Using Version Control Systems like Git helps one to keep track and maintain multiple versions of their code.

Wonder why it takes time to get software product to market? It is because of this increased development time that assures the best possible quality of code is shipped to the customers.

10. Read lots of code

Reading others code is not like reading a storybook. It is a lesson, rather a challenge.

It helps you to reflect on your strengths and weaknesses. You get to see different approaches and mindset of other programmers towards the same problem.

Put yourself in someone else’s shoes.

A good exercise is to pick up a problem and work on it in parallel with your friend. At the end of the development, discuss the solutions and share your analysis.

Note: Reading others code does not mean to blindly follow it and copy. You must examine and study the code and draw your own conclusions. Failing to do so may be a big mistake and, before you know it, you may have imported a bug-factory in your work.