I have been a software developer for almost ten years now. Throughout this time I've had all kinds of experiences in this business: from working by myself to managing a team and from creating software from scratch to maintaining existing software.
Software Development is more than just ones and zeros. It involves analyzing, understanding, improving, negotiating, maintaining, testing, and many other things aside from writing code. As with other things in our lives, we can always take a lesson or two. These are a few of the lessons that I learned throughout my career in software development.
Analyze problems from all points of view
There are problems everywhere in software: from the ones that your customer has and you're trying to solve by developing a solution, to the bugs you will face throughout the development cycle. No matter what kind of problem it is, always try to thoroughly understand it, from all points of view.
When it comes to problems that our customers face, we tend to look at them only through a certain lens, especially when asked to develop a solution that they already have in mind. It's important to understand what is the problem, why it happens, how it impacts the business, and who faces it. With this sort of analysis, you can have better insights into what to do to provide a real solution to the problem.
Bugs are another kind of problem that you may face in Software Development. With this kind, I've seen many developers look at them through their biased lens, without really trying to understand what's happening, but just trying to suppress the error message or fix the wrong behavior.
If you just get rid of a problem, without truly understanding what is going on, why it is happening, then you won't be able to prevent it in the future. You need to have a deep look into it, understand what caused the problem (is it a syntax or a logical error?), comprehend its context (what was it trying to do? what is the environment?) and what can be done to fix it. Only dismiss the problem when you are sure of what happened, what caused it, and that you truly solved it.
Don't let your opinions cloud your judgment
Of course Airbnb made mistakes the first year! Some came from our own preconceptions. When we started, we designed our interface for ourselves, Internet-savvy twentysomethings. We never considered the role of good eyesight in our interface - font size, vernacular; it all matters.
Joe Gebbia, co-founder and chief product officer of Airbnb
Many decisions go into a piece of software: what language to use, what framework to adopt, where to deploy, etc… Of course, some of those will be easy decisions to make, based on your previous experiences with them, and others won't be as easy, and they will require more thought and analysis.
In the software industry, there have always been misconceptions and judgments about tools that are propagated throughout the whole industry. Some say that a given programming language is awful because of its types, others say that an OS is extremely safe because it can't catch viruses, among other opinions that are out there.
The point is: technical decisions will have a huge impact on the usability, performance, and maintainability of your software, so you need to make sure you are choosing the best possible options. For this reason, you can't let yourself be guided just by feelings, misconceptions, or preconceptions. Try options for yourself, and look at each of them with a critical eye, prove their pros and cons and decide for yourself.
There are multiple ways to achieve a goal
There are many situations in our lives where there are multiple ways to make something work. For example, a car can run with gasoline, ethanol, or even electricity. Each method has its advantages and drawbacks, but none of them are wrong, as long as the car can get you from point A to point B.
The same thing happens with software. You may achieve your requirements using a certain language, library, or algorithm that someone else didn't use but still got the same result. So, don't hate yourself because someone did the same thing differently.
Use this truth from your advantage, and learn from different approaches to problem-solving. If you used a pre-made solution, like a package, then learn how it works and how you can do the same thing without using any packages. The knowledge you acquire from learning different ways can help you perform in different situations where you can't use certain solutions, like in an interview or an enterprise environment, for instance. It will also help you with my next tip.
There's always room for improvement
The first time we do something won't always be the best, and you won't always make the best version of something in your first try. My first ever article was awful! And I didn't write this one in my first attempt but was always improving upon a rough draft (I might even update it after publishing 😅).
Even after writing code for almost ten years, I still see a lot that can be improved in code that I write today. That's why there's the code refactoring process exists. It's to improve upon something that was written before, whether making it clearer, faster, more organized, or all three at the same time.
Sometimes we know what should be improved right after we created something, but there are times when you have no idea what to improve upon. That's where the opinions of others can be really important. Ask your end users if it's running fast enough, ask your operations team if your code is draining resources, ask your peers if you are writing comprehensible code. Be open to criticism and ideas. There's always more to improve, in your code and yourself.
Never stop learning
IT is in constant change. Every day there's a new library, a new package, a new programming language, a new way to do the things we are currently doing. The need for constant learning is real if you want to stay current.
Don't think that just academic knowledge will be enough for an IT career. Schools and colleges can't always keep up with the fast pace of change in this industry. Much of the knowledge you'll use daily will come from trying and learning by yourself.
I'm not saying that you shouldn't have an IT degree or that you won't use anything that is taught in any of those. There are key concepts and methods that you can learn from a degree and will give you a solid basis for a career. But don't depend only on that.
Always look to learn more. Learn more about what you do today, how you can do it better. Learn other skills that will help you perform your tasks. If you are a front-end developer, try to learn a bit about how the back-end works and how to create a simple one. If you are a back-end developer, learn about the other side.
Bottom line: never think that what you know today is enough. Maybe what you do today will be obsolete in a few years. Don't let yourself become obsolete too.
Conclusion
I've given you a few of the lessons learned in my years of experience as a software developer. Of course, most of what you read above is oriented towards IT, but it can also be applied to our personal lives.
Analyze situations in your life thoroughly and you will be able to understand why something happens, why someone acts the way that they do… It will help you become someone more understanding of others.
Don't let your opinions and preconceptions get on the way of understanding something or someone, of learning a new skill, of doing something new. Try things for yourself and learn if they're valuable or not.
There are multiple ways to achieve goals in our personal lives, and different people can find a successful life in different ways. Don't compare your life to what others have done, but take lessons from it for your improvement.
And finally, never stop learning something new. Don't limit yourself to learning tech, but learn a new skill, a new hobby, a new passion.
I hope these lessons help you as they did to me. For now, this is it - thanks for reading.
Top comments (0)