The Honest Truth
To be honest, I am not really a great programmer – that is not what you get highly paid for.
This is something that even software engineers that have been in the industry for many years do not understand. Also, those that craft code that is way better what I can do.
Let’s dive into the 5 things that will increase your salary as a Software Engineer.
Key Skill #1: Decouple Code
To decouple code is about writing and designing code with loose coupling. The best way to understand it, is to understand what strong coupling is.
Strong coupling is basically what happens when you write code and it grows organically.
What do I mean?
Well, you let the code evolve from the first line of code until the last line of code solves the problem.
You end up with code, which is difficult to test, debug and maintain. If you make a change one place in the code, you do not really know what happens in the other parts of the code.
This happens for everyone, which does not think about encapsulation.
Encapsulation is about creating classes with an agreed upon interface. This hides the actual code away.
As an example consider the RestApi class above. If the way you call and parse the result from the REST API changes, this can be hidden in the method call. Hence, if you use call in your code, you most likely do not need to change anything at those places if the nature of the REST API changes, you can make those changes inside the method call.
The same for class Storage. Imagine you want to change the way you store data. You can make all the changes to that inside the Storage class, without needing to make any changes to the code where you use the class Storage.
Software Engineers that master decoupling craft code that is easy to maintain, debug, and extend. This is a key skill when you make production code.
Key Skill #2: Source of Truth
Every modern system uses data and the most common pitfall when working with data is not to understand the Source of Truth.
The Source of Truth means that data is mastered, and most importantly, edited only in one place.
You actually see this problem all places.
The above screenshots where taken simultaneously from two different pages of my YouTube channel.
It claims two different numbers of views.
Which one is right, which one is wrong?
The problem is, that it reads the data from different places. That data is stored temporarily in different places and not synchronized fast enough to be given the same numbers.
Consider the following problem I just encountered. I was creating a system view of the data types of files in a storage and exposing them.
Now the Truth about the data types is in the Storage, not in my view.
Now someone else needs the Data types of the data in the storage. Since I already extracted them, they were inclined to just take them from my new system (see image above).
The problem comes, when someone changes the data type of, say, Data A. Then it is wrong in my system (the middle one), and surely wrong in the last system (on the right).
I might remember to synchronize the data types, but what about their system. Did they remember? Anyhow, it can easily end up with a data ecosystem, where there is a lot of wrong data.
Understanding this is crucial when creating systems.
Key Skill #3: Think Long-Term
Most developers only focus on solving the programming problem they are hired to do. They get a feature they need to implement. They just implement it and move on to the next one.
A more experienced programmer, and highly paid programmers think differently about it.
They try to craft code in a way that makes it easy to.
- Find a bug in the code.
- Extend the code with more functionality.
- Add tests to make sure someone in the future does not break the code.
But not only that, also consider the following.
- What can go wrong in the module?
- How can you make logging and metrics to know if it would happen?
Key Skill #4: Terminology
This one was a big surprise for me.
But actually how we use words and concepts is very different from team to team, and it also change over time.
What can go wrong?
Well, it does it all the time. You sit in a meeting with someone else, another team. You agree to implement some things. The meeting ends and everyone thinks they know what to do.
The problem is, that you all understand the concepts you use differently.
A highly paid software engineer will always ensure that all participants have a common understanding of what is agreed on. Asks about what is meant by the used concepts.
You will be surprised by the different ways we understand things.
Key Skill #5: Persistence Debugging
Most only care about finding the bug and move on.
When a system goes down, it can cost organizations millions of dollars per hour. Being able find bugs and ensure you catch them faster next time is crucial.
This is where concepts like leading indicators pays a big role.
A leading indicator, is something that can indicate that a crash might be on the way.
Sometimes bugs only show up on certain occasions, and you cannot reproduce them. Then you need to add logging and metrics to your module to get more evidence to your hypothesis.
Want to learn more?
Get my book that will teach you everything a modern Python cloud developer needs to master.
Learn how to create REST API microservices that generate metrics that allow you to monitor the health of the service.
What does all that mean?