For many of us, writing code and developing software is one of best profession in the world. However, software developer habits are full of obstacles, both visible and invisible. This work requires a constant, proactive approach in order 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 such an impact in deploying their productions. However, there are also so many developers that are stuck with wrong habits, old programming techniques and not-so-cool mental patterns that do not allow themselves to express their full potential, or at least, to improve their programming skills.
In this article, we’ll dig deep into the most successful developer habits and see how you could apply them in 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 whatever work he does, he’s the one who love that kind of work too. You can’t be able to write good code or develop good software if you do not love doing it. Someone once said: “code is poetry“, because writing code is truly an art.
So, in order to get better at writing code, simply start to love writing code more. Try to feel passionate about digging into the code mechanics, and explore more the good-feeling 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
With the terms “development stack” we 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, for example, is full of different development stacks, and each one has got his own pro and cons.
In order to be a very good developer, you really have to gain mastery in all the areas that are concerned in a particular development stack. Not only you should dig deep into the language’s mechanics, but you should be able to write good code using a professional IDEs, knowing its features and shortcuts that let you save a lot of time in developing software and applications.
The “stack” is composed of many different tools combined with each other, and the whole is definitely greater than the sum of the single parts. There’s no such a good developer that knows, for example, PHP, but does not know how to interact with a Database technology. It simply doesn’t fit in. Moreover, in the modern world of software development, the 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 can specialize more in a side rather than another, he should not completely avoid the other parts of the whole.
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 like 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.
The fact that you use a tool in a particular development stack doesn’t always imply that you shouldn’t learn other tools too. In fact, many times quite the contrary is right.
Always feel like you are in the “dojo”
Just like, as a developer, you shouldn’t underestimate yourself, you shouldn’t get over yourself, too. A successful developer is never satisfied with his level of knowledge. In order to do this, you have to merge with your passion, trying to improve your skills day by day. Every day you should be better at doing something related to your role of software developer, than you were the day before. You have to feel like you should reach the point where you master it better than anyone else on Earth. Always be humble and try to learn something new every day, from everyone. You must feel as if there’s a lot more to know about it. The real master is the one who always feels like a student in the “dojo”.
I keep on meeting developers that in the past gained some kind of mastery over a specific programming topic, that they feel like they know everything that is concerned. In most cases, it is not so. Their code could be improved. Their general and specific understanding of a particular topic has got some flaws. The language or framework they use offers more than they can actually grasp. The libraries or particular techniques in which they specialized may be replaced in favor of new, more robust ones.
A successful developer is never really at peace with his actual knowledge. The world of information technology and the software development branch are in a constant, steady evolution. So, you have to keep on sharping your skills, day by day, week by week, month by month. Many people feel like if they have to get back on study on books, they would feel ashamed. The contrary is right: programmers that keep on sharp their knowledge are by far the best ones.
Make the quality of code a central point of your profession
In the context of software development, everybody can write some code, but not everyone can write good code. A successful developer habit consists in always writing good, clean, flexible and robust code. Just like there are soccer players that are able to do magics with the ball, and others that despite being good are not on the same level, there are many developers that do magics with code, and some others that do not.
This is a very important point to understand: if you are writing bad code now, and you’re doing nothing to improve that code, you will keep writing bad code. And in this way, chances are that writing bad code would probably become a habit. Writing bad code always produce some kind of bad results, both externally and internally.
Many developers think that they have to write some code that just works, no matter how it is written. They may think this because their boss told them there’s such a 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 the ones that 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 you: it allows a developer to distinguish himself from the so-called “average developer“, and dig deep into the mechanics of a programming technology allowing the production of high-quality software whose clients would love to get their hands on.
Another developer habit: “Invert the desire”
We said many times that a successful developer habit consists in not feeling fully satisfied with his current knowledge, sticking his nose into many different software technologies. But this doesn’t mean that this kind of approach is an obstacle-free route. So, in order to deal better with the process of learning a new technology, I will give you a suggestion that you may find very useful.
When it comes the procedure of learning a new programming language or a new programming technology, you should wield what some people call “the inversion of desire“. Normally, we humans consciously and subconsciously strive to desire internal relax and peace. This is why some developer tend to focus on the technologies they already know and rarely develop interest in other languages or technologies.
This happens because the process of learning a new language or technology involves feeling pain, pressure, anxiety, and a massive usage of the brain. If you desperately try to avoid those feelings or try to avoid mind/energy usage, you will never be able to overcome your actual limitations.
But 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 the good track to the success.
The pain could come in many different manners: studying things that you think are not quite useful, using deeply your brain to understand many different things and difficult concepts, studying professional design patterns to be professional at writing code and not keeping yourself at the beginner level, using new development tools and totally different strategies (maybe you have to reset your former mindset) and many other smaller, but equally important things.
A developer will find many personal reasons which could bring this kind of pain to him in order to learn some new professional knowledge. For me, the major pain comes with wanting to learn and master a new tool as quickly as possible. I don’t feel satisfied with learning some things about a language, I usually want to dig deep into it, as if any detail has been covered and all the questions have been answered.
However, this kind of developer habit isn’t always the best choice. In fact, in order to master a new skill, you have to give yourself the right, physiological amount of time required by your mind to fully assimilate that skill, without being too hasty. The major obstacle for everyone is surely the starting point, when you face the new technology for the first time. This is the toughest time for sure. But you have to be strong and get out of your comfort zone, namely the things you already know, and the way these things works and feels about.
So, in order to master the new knowledge, you have to master your pain, you have to desire more and more challenges, and not try to avoid them. Always remember: software development is a beautiful topic, and your attitude will pay off in so many ways.
If you are looking for a job as a software developer, here you can find a series of career advice for devs.