7 lessons that I learned in ten years in development
Photo by: Neonbrand. Taken from the resource Unsplash
My application development experience does not boil down to just victories. Where failures happened more often, and serious ones. But only making a mistake, a person receives the necessary knowledge, so now I’m even glad of my mistakes.
I was lucky to work with real professionals, in different companies – large and small. If not for these people, I would never have become the specialist that I am now.
Today I will talk about the seven main lessons that I learned over ten years in application development. Sit back, relax and enjoy reading – I hope at least some of the information will be useful to you.
1. On the path to success, you need to survive a thousand failures
I remember well my 14 years. A friend of mine at that time was creating his own website, and I was very inspired by his ability to write code and cool web pages, which turned out as a result. And once I asked him – how do you do this? The answer helped me a little, rather disappointed. After all, a friend said: just open the notebook and write.
Fast forward to a later time – my first year as a developer. That friend’s answer motivated me to experiment with HTML and CSS. Naturally, I made a lot of stupid mistakes, for example these:
- built sites only using
- used for page layout
- used for almost everything
The list goes on and on. In my defense, I will say that, making mistakes, I learned to distinguish the right from the wrong. And also, becoming an application developer, I nevertheless coped with these problems, because my colleagues regularly gave me feedback.
The key to success at work is practice. Before you achieve anything, you will have to make a huge number of mistakes. But failure is not so bad! This is just part of the process: you work on your mistakes in order to get a better result next time.
2. Anyone can learn to code!
In general, you are mistaken if you think that only a genius can become a developer. Brains, of course, do not hurt. However, only a permanent practice will make a good specialist out of you.
This sounds especially logical when comparing programming with sports. Before getting to the Olympic Games, athletes have been training for many years. Be patient and practice more often!
3. Senior developers also doubt
It always seemed to me that these smart, experienced professionals are confident in their skills. However, they have the same doubts as the juniors.
Many seniors suffer from impostor syndrome, some more often, some less often. This also happens to me from time to time. But I think there is no need to be ashamed. We are all human, and we don’t have a hard drive in our head to take and load gigabytes of knowledge there. Yes, this is useless!
I realized a lot when one of my leading developers could not solve a problem, although I sat there for hours. At that moment I thought: it’s okay to admit that you don’t know something yet.
Seniors become seniors, because during their career they have been mistaken many times. But if a novice developer addresses a question that we don’t have an answer to, we also have the right to say: “I’m sorry, I don’t know.”
4. The most important skill is communication.
If it seems to you that the most important thing in programming is the ability to write code, think again!
For many years I worked in large and small teams, where work on projects was in the SCRUM format. And in every retrospect, someone always said: yes, we need to improve communication, because there and there everything went wrong. If we interacted better with each other, the problem would have been prevented.
If you work on your own, this, of course, is not your case. But in a team, communication becomes an extremely important thing.
Often the success of a project depends on communication no less than on programming skills. If you work in a team of cool developers, which is bad with communication, you have big problems.
5. Mistakes? So next time test more
We are developers and we don’t really like testing. Of course, you can test one, the other a little, but in-depth testing of scripts is not about us, right?
If your code often contains errors or bugs, pay more attention to testing. Some do it manually, but I recommend spending time on automated testing (creating unit and integration tests, penetration tests, etc.). This will save you from problems in the future.
Yes, creating tests is not as exciting as working on new functionality. But they will save you time for cool features!
6. Help others!
Something about my character: I love helping people. However, I came across developers seniors who were cutting with juniors. I hate it when they do it!
When you become a great lord, try not to forget where you started. Remember who helped you along the way and how you felt. Because good is coming back. And if you are cutting to people, expect the same from them!
7. Write articles to stimulate your learning
I did not study well at school, my grades were not very high. But as a developer, I finally found a learning method that suits me. (And cheers!)
Trying to put a complex prototype in my head, I set out to write an article about it – as if I were explaining the principle of operation of this prototype to someone else. I always start with the code: I try to make it work, then I break it again. I need to fully understand why everything is so, and not otherwise, and also what I can do if the code for some reason does not work.
In my case it helps. I regularly re-read my posts to remember how a particular prototype works.
Thanks for reading. I tried as much as possible to talk about the most important lessons that I learned over ten years of application development. I hope you take this information into service, and it will be useful for your career.
I am also interested in what useful lessons you have learned from your own experience. It doesn’t matter who you are – student, junior, senior. Let’s learn from each other!