For many of us, writing code and developing software is one of best professions in the world. However, software developers often have habits that pose obstacles, both visible and invisible. This work requires a consistent, proactive approach for a developer to really be successful at writing excellent code and developing high-quality software.
There are many developers that are good at writing code and making programs, whether they create web, mobile or desktop applications, and they make a big impact when they deploy their products. However, there are also many developers who become stuck through bad habits, old programming techniques and mental patterns that do not allow them to express their full potential, or improve their programming skills.
This article digs deep into the habits of the most successful developers and see how you could apply them to your daily life.
The first successful developer habit: love to code
This may sound a little simplistic or funny, but it’s a crucial point. Someone who is good at the work he does is usually also someone who loves that kind of work. You can’t write good code or develop good software if you do not love doing so. Someone once said: “code is poetry“, because writing code is truly an art.
In order to get better at writing code, you simply need to find a way to love writing code more. Try to feel passionate about digging into the mechanics of your code, and explore the enjoyable, positive sensations that come with seeing your own creations in action in many different environments!
Master your dev stack, but keep an eye on other stacks too
We us the term “development stack” here to mean the set of languages, libraries, IDEs and tools (including OS, database server and application server) used for application development. For example, people may refer to the LAMP stack (Linux, Apache, MySQL, PHP), or to the Microsoft Stack (Windows, IIS, SQL Server, C#/.NET). The world of web development is full of different development stacks, for example, each with its own pros and cons.
In order to become a very good developer, you really have to gain mastery in all the areas relevant to a particular development stack. You should not only dig deep into the language’s mechanics, but you should be able to write good code using professional IDEs, knowing the features and shortcuts that allow you to save a lot of time in developing software and applications.
The “stack” is composed of many different tools combined with one another, and the whole is definitely greater than the sum of the single parts. There’s no such thing as a good developer that knows PHP, but does not know how to interact with Database technology, for example. This simply doesn’t work. Moreover, in the modern world of software development, labels such as “front-end developer” or “back-end developer” are a bit misleading. A successful developer should have a fair knowledge of the entire stack, and although he or she may specialize more in one side than another, it’s unwise to completely avoid the other parts that make the whole picture.
Lastly, in addition to a very good understanding of the mechanics of your development stack, you should keep an eye on other stacks too. Just as knowing how to speak in English, French and Spanish allows you to establish a good quality dialogue with many different people, being able to write code in different stacks allows you to expand your knowledge of programming in so many different ways.
Each development stack offers different approaches to software development, as well as different programming paradigms, architectures and patterns. In the process of learning a new technology, you may just fall in love and start to use this new discovery in your production environment, because it does some things better than what you’ve previously used. This approach applies not only to full development stacks, but also to single libraries or technologies in a particular stack too. In the Javascript world, for example, you can wield several different, but equally good frameworks, such as Angular, React or Vue. The PHP stack offers many different frameworks too, including Laravel, Symfony, Zend Framework, and so on.
The fact that you use a specific tool in a particular development stack doesn’t mean that you shouldn’t learn other tools too. In fact, many times quite the contrary is true.
Always feel like you are in the “dojo”
Just as you shouldn’t underestimate yourself as a developer, you shouldn’t become over-confident either. A successful developer is never satisfied with his level of knowledge. In order to do this, you have to merge your knowledge with your passion, trying to improve your skills day by day. Every day you should strive to be better at doing something related to your role as a software developer than you were the day before. You have to feel like your goal is to reach the point where your mastery of these skills is greater than that of anyone else on Earth. Always be humble and try to learn something new every day, and from everyone you meet. You must feel as if there’s always a lot more to know. The real master is the one who always feels like a student in the “dojo”.
I keep on meeting developers who have previously acquired some degree of mastery in a specific programming topic, and now feel like they know everything that area involves. In most cases, that’s not really true. Their code could be improved. Their general and specific understanding of a particular topic has some flaws. The language or framework they use offers more than they currently grasp. The libraries or particular techniques in which they specialized may have been replaced by new, more robust options.
A successful developer is never really at peace with his current level of knowledge. The worlds of information technology and software development are in a constant, steady state of evolution. Developers have to keep on sharpening their skills, day by day, week by week, month by month. Many people feel that going back to study from books is somehow something to feel ashamed of. On the contrary: programmers that keep on deepening their knowledge are by far the best.
Make quality of code a central point in your profession
In the context of software development, everyone can write code, but not everybody can write good code. A successful developer makes a habit of always writing good, clean, flexible and robust code. Just as there are soccer players who are able to make magic with the ball, and others who are good, but just not on the same level, there are developers who make magic with code, and others who do not.
This is a very important point to understand: if the code you are writing now is bad code, and you’re doing nothing to improve that , you will keep writing bad code. In this way, chances are that writing bad code will probably become a habit. Writing bad code always produces some kind of negative result, both externally and internally.
Many developers think that they simply have to write a code that works, and that it doesn’t matter how it is written. This may be because their boss has told them there’s very little time left, and they have to deliver quick results. However, this kind of approach to software development is not good for a developer. Successful developers are those who take time to study how to write good code – namely implementing robust and well-known design patterns, using flexible architectures and good practices in relation to a specific programming language.
This approach results in significant benefits for the developer: it allows an individual to distinguish themselves from the so-called “average developer“, and dig deep into the mechanics of a programming technology, in turn allowing the production of the sort of high-quality software clients would love to get their hands on.
Another developer habit: “Invert the desire”
We have said many times that a successful developer never feels completely satisfied with their current level of knowledge, and continually sticks his nose into many different software technologies. But that doesn’t mean that this kind of approach is an obstacle-free route. In order to deal better with the process of learning a new technology, here is a suggestion that you may find very useful:
When it comes the process of learning a new programming language or a new programming technology, you should engage in what some people call “the inversion of desire“. Normally, we humans both consciously and subconsciously desire internal relaxation and peace. This is why some developers tend to focus on the technologies they already know and rarely take an interest in other languages or technologies.
This is because the process of learning a new language or technology involves experiencing discomfort, pressure, anxiety, and using the brain on a massive scale. If you are contantly trying to avoid those feelings or to avoid mind/energy usage, you will never be able to get past your current limitations.
If you learn to “love the pain” that comes with learning a programming language or becoming better at your current language stack, you’re on a good track to the success.
This discomfort may come in many different forms: studying things that you think are not really useful, using your brain intensely in order to understand many different things and difficult concepts, studying professional design patterns to improve your code writing rather than remaining at the beginner level, using new development tools and totally different strategies (maybe involving a reset of your former mindset) and many other smaller, but equally important things.
A developer will find many personal reasons which could inspire them to experience this discomfort in order to acquire some new professional knowledge. For me, the major discomfort arises from wanting to learn and master a new tool as quickly as possible. I don’t feel satisfied with learning just some aspects of a language – I usually want to dig deep into it, until every detail has been uncovered and all my questions have been answered.
However, over-indulging in this kind of habit isn’t always the best choice for a developer. In order to master a new skill, you need to allow yourself the appropriate amount of time physiologically required by your brain to fully assimilate that skill; don’t be too hasty. The starting point is the most common major obstacle for everyone, when you come face-to-face with the new technology for the first time. Starting is undoubtedly the toughest moment, but you have to be strong enough to leave your comfort zone – leave the things you already know, the way these things work, and the way you feel about them behind.
In order to master the new knowledge, you have to master your discomfort; you have to desire more and more challenges, rather than trying to avoid them. Always remember that software development is a beautiful topic – this attitude will pay off in so many ways.
If you are looking for a job as a software developer, you will find a series on career advice for devs here .
