Ten character traits that combine to make a better developer

Developers at the top of their game IMHO possess 10 key traits, from the willingness to transgress, an affinity with simplicity and an understanding that strategy means sacrifice and above all communication. Rules are rarely best broken, but pushing boundaries and leading innovation from curiosity and a willingness to choose are signs of developer success.

1. Empathy

Our prime directive is to deliver, through the use of IT, a business benefit for users and an organisation.

By looking in the mirror of a user we can better understand and deliver what's best for them.

It's so basic, and yet so easy to overlook because of the processes we often use to streamline and abstract development tasks.

2. Curiosity

A sense of curiosity is immensely important to developers, precisely because that trait asks users and organisation what they are doing and why.

Learning about a business and its users has a natural tendency to want to understand things.

Understanding and diagnosing their requirements is an easy way to strategically deliver what they want rather than just what they asked for.

3. Comfort with imprecision

Whilst computers can deliver precision, users and their requirements are often fuzzy. Real world apps need to test against and deliver repeatable data points.

Being comfortable with fuzzy imprecision, and delivering something that accommodates real life, within constraints but without misleading, offers useful buy in.

Well rounded individuals have an understanding of the balance between real life and a precise outcome are better placed to bring them together. Details matter and an ability to square that circle is a harder and all too often rare trait to find.

4. Making Time

Almost without exception, every IT department is under siege. It's an expensive resource and management have a duty to get the most out of it. The biggest barriers to strategic planning are tactical efficiency and firefighting.

Unlike those overworked who say they don't have time, the best developers appear to have more minutes in their day.

Making time is one of the best traits by breaking out of the negative cycle and planning strategically, avoiding fires and delivering better outcomes for all.

5. Long-term vision

Although COBOL, like assembly, is still a thing, most of IT moves forward, perhaps with bumps, but there are usually always newer, faster and better ways of doing things.

While someone is always inventing a new framework for something, a trait identifying what will deliver significant long term benefits is harder to master.

Containerisation offers so many benefits, and yet less popular choices such as FreeBSD Jails offer better security and are lighter weight than many others, and Bhyve virtualisation offers multiple hosts including Windows. NoSQL may have been a briefly useful alternative to mainstream databases, but PostgreSQL has been making steady strategic and incrementally significant strides forward both in terms of functionality and performance for many years.

Successfully deciding which tactical path to take towards a longer term vision is a trait usually developed after making and learning from poor ones. Learning from others only goes so far.

6. Short-term doing

Getting stuff done is what we are paid to do. Bugs get in the way, incompatible libraries frustrate our efforts, but delivering is an essential trait we all need.

Long term strategic vision is essential to long term success, but to get paid today we usually have to deliver today. Few are able to combine both skills, it's easy to copy and paste from Stackoverflow with little thought, but once mastered, context switching between many different hats, often in seconds, is a most valuable trait to acquire delivering better code that lasts longer and/or has a better transition to a more beneficial outcome.

7. Choicefulness

A terrible word, but choicefulness is an important concept. There is rarely a single right path, and it's easy to choose something we either know, or when rushed the first thing that works.

From a strategic position, what not to do can make sense. Too many alternatives and anarchy as well as a maintenance nightmare will surely follow. Too few and it's harder to deliver elegant, flexible or maintainable code. Monolithic to microservices is a spectrum - a useful trait is to strike a balance between them and choose a range with a sufficiently detailed roadmap to navigate those inevitable changes when they happen making IT so interesting.

8. Make things look simple

Simple enough to understand and clear enough to follow is a trait we could all benefit from improving.

Too simple and it'll be of little use, too complex and it too will be ignored, or worse misused and abused.

Whether it's an app, service, strategy or concept, communicating actions and ideas can only be effective when we speak the same language. Like a fractal, with rocket science it's easy to see the bigger picture, zoom in and there is still clarity in the detail.

From workflow to strategic outcome, clarity is easier to follow, and when circumstances change, make challenging and improving the next iteration natural and easier.

You can tell when someone has this trait, the work they produce looks straightforward.

9. Rule breaking

It's easy to get carried away with this one. Rules are there for a reason, RFCs doubly so. But the boundaries of what can be achieved need constant pushing.

Never forget that contingencies are essential, and automated testing is a useful aid rather than a guarantee.

If there's one trait above others, it's the determination and ability to document clearly for those who will follow. Our future selves will be eternally grateful for any help in simplifying and explaining details that matter.

10. Learning and adapting

The future is constantly changing. We should all be learning from what happened in the previous year. Our failures are as valuable as our successes.

It's hard to change direction, even when there are obvious and significant issues.

Voyager space probe launched in the 1970s has a stable code base that won't change. However the IRS with operational assembly code from the 1960s and banks using COBOL aren't good examples of stability but of an organisation who finds it difficult to adapt and move forward.

Learning and adapting has to be the final trait of a good developer because it offers experience and makes us smarter. Whether we succeeded or failed to meet our personal goals is of modest importance, it's when we review what we learnt over the previous year, and what our plans are for learning over the next that matters.