It was time to put our new vendor product into a new environment, our integration environment. This was a big deal because we previously installed it manually in our development environment and this is the first time that we would be using an automated build/deploy process to install it into our new region. We would also be using slightly different configuration.
The deadline was getting close. We had to start UAT within a week. If we could work out the kinks in the integration region we could quickly move to the UAT region. However, things would not go smoothly.
The code was deployed. We started up the server and the runtime (JVM in this instance) crashed. It took us a day and a half of pulling our hair out to figure out the little bit of configuration that we missed that finally made it work.
Why am I telling you this story? If you are new to software development, this is in your future. That is, if you haven’t experienced it already.
Programming is at times less about algorithms and data structures and methods and classes and types and all of the other stuff you learn about in school (or code camp, depending on how you learned) and more about two P’s: persistence and patience. These two qualities will take you much farther than just knowing how to write a quick sort.
To persist is defined as “to go on resolutely or stubbornly in spite of opposition, importunity, or warning.” That is certainly what software developers will need to do at some point in their career. This doesn’t mean that it is every day, but it will happen eventually. You will have a bug that perplexes you. You will stare at it for quite some time and have no idea why it doesn’t work. You will need to persist, to not give up. You will also get frustrated, as I was when a simple deploy to the integration region took a day-and-a-half to finish.
This is not only applicable to errors. You may have to persist to get a new tool adopted. A form of persistence is refactoring code or constantly improving on code and architecture. This is definitely valuable to a team. Being passionate usually entails persistence.
What about patience? To be patient is defined as “bearing pains or trials calmly or without complaint.” There certainly are pains and trials in a software development career. Bearing them is going to be important, although we may not always live up to the “without complaint” part of the definition.
Why is patience important? Concentrate on the word “calmly” in the definition. Whatever issue you are facing, losing your cool is not an option. No one wants to work with a raving lunatic. When faced with a problem, keeping calm will allow you to attack the problem systematically and thoroughly until you find the answer.
Patience also can give you a bit of perspective. It can help you to understand that, for the most part, the world will not blow up if you can’t fix this problem right away. That doesn’t mean that you are nonchalant about fixing the issue, but that you remain calm, focused and professional while you figure out the error.
I was really frustrated during my troubles with the integration environment, knowing my team was counting on getting this and the UAT environment up and running. However, persistence and patience allowed me to keep my cool and work toward a solution. Of course, others helped me out and you should never be afraid to ask for help. However, your attitude makes a difference.
In the end, the main reason why persistence and patience is so important is because is feels so awesome when it finally works.
(source of featured image: This great LinkedIn post)