Not a long time ago, knowing some clean code techniques, a programming language well, and basic frameworks to create a monolith application was enough to build software, nowadays the game changed.
In the cloud era, a software developer has to be more of an engineer than only a code developer. This is even more true with AI (Artificial Intelligence) which is creating code from a simple sentence. We have to accept that times change and we have to adapt to new technologies and challenges.
What is a software engineer?
A software engineer is someone who will first understand the big-picture real-world problem and will elaborate on a technical solution to solve it. Therefore, the software engineer must know a vast range of technologies. Also, keep in mind that it’s not necessary to know every technology in deep. Instead, you should know what technologies are available in the market and what problem they solve so you can use them to solve a specific problem.
Trying to learn every technology in deep is a common mistake for many software developers. They think they will get value from studying many technologies in deep. However, it’s much more valuable to understand and master fundamentals rather than trying to master every shining toy that shows up in the market.
A software engineer is very effective at asking questions, understanding the real problem, and then and only then he or she will be able to come up with a solution. That’s a highly valued skill for any company nowadays, they want software engineers who communicate well and understand the technical problems clearly.
The Principles to Develop High-Quality Cloud Software
In monolith software, it was important to have a robust software lifecycle but with Microservices I would say that this is mandatory. Let’s see what principles we must keep in mind to develop a high-quality Microservice.
- Accessible: Microservices must be accessible in any country the customer needs to access it. Therefore, you might need to deploy your Microservices in strategic countries and servers.
- Secure: Without security, anyone can easily invade your server and steal whatever they want from your software. Therefore, security is a very high priority when developing Microservices. Fortunately, there are technologies and tools out of the box that makes a Microservice secure much more easily.
- Scalable: When designing a Microservice you must know how many users will be using it, and what it will do exactly so that you can configure a decent cluster of virtual cloud machines for it. Then you will be able to use the available tools to solve common scalability problems.
- Monitorable: Debugging Microservices is very hard. That’s because Microservices will communicate with each other via cloud services and debugging as developers used to do with a monolith is no longer a reality. Instead, software engineers must use powerful monitoring tools that will capture, latency, performance, and logs so that whenever there is an error on Microservices they can send an alarm to a developer to solve the problem.
- Maintanable: To create a robust infrastructure for Microservices in the cloud is very difficult and complex. Therefore, if we create that in the AWS (Amazon Web Services), for example, all the configuration will be lost. Therefore, there is an interesting concept called Infrastructure as Code where we can create all our Microservices infrastructure as code, therefore, being able to maintain it more easily and automate the whole infrastructure creation, migrate it, and understand how the infrastructure was created since the code is the source of truth.
- Testable: Nowadays there is a vast range of tests we can perform in Microservices. Some of them are Unit tests, Integration Tests, Smoke tests, Performance tests, Stress tests, Canary tests, End-to-End tests, component tests, load tests, and the list goes on. Therefore, it’s important to build Microservices in a way they are easily tested. As mentioned before, debugging Microservices is very hard even with the technologies we have nowadays.
- Automated: CICD (Continues Integration Continues Delivery) is a must-know concept to deliver high-quality software. There are many tools that help us to integrate code, build, test, and deploy software in the cloud. To be a good software engineer you must know those tools, and how to use at least the basic of them because software engineers will very often deal with the software development cycle.
us
Once you know the principles from above to create good-quality Microservices, now it’s time to use your engineering skills to create software that is following them.
What Technologies Must a Software Engineer Know?
Before everything, a software engineer must understand the fundamentals of programming such as:
- Algorithms
- Data Structures
- Solid Principles
- Design Patterns
- Clean Code Techniques
- Database SQL
One of the most experienced software engineers I ever worked with also mentioned that you become a much better software engineer once you learn other programming languages. That’s totally true because by working with another programming language you will notice that all the fundamentals are there and you will also learn awesome tricks that your main programming language is probably not able to accomplish.
The programming languages that are strong in the market right now are:
- Java
- Golang
- Python
- Kotlin
Once the bases of programming are mastered, then in order to go to the next level, you must go beyond coding. Microservices are the new default in the market, and it also makes things very complex. Therefore, there are many technologies and tools to know what they do. Take a look at the following article to understand what are those technologies:
The Ultimate Guide of Microservices Technologies for Java Developers
The Recognition of Problems and Patterns to Solve Problems
As a software engineer, one of the most important traits is to be able to recognize problem patterns and implement a suitable solution. One way to achieve that is by getting exposed to as many concepts and tools as possible. You can easily do that on some courses platforms such as:
To enrich your learning, you can do what you are doing now, reading articles is a good way to see different technologies. Contributing to open-source projects is another powerful way. Playing around with technologies that are fun for you is very good to keep your skills sharp as well.
To summarize, the greatest key to being a good software engineer is to know as many tools as possible, preferably the ones that are popular in the market. When I say that software engineers should “know”, actually I mean that they should know what that vast range of tools and technologies do and why they are important.
If you try to master each and every technology, you will spend years and there will be no benefit from it. You can also create some small POCs (Proof of concept) to see what this new tool or technology is capable of doing. A very important trait for a software engineer is to be constantly curious about what is going on in terms of technologies. Again, be careful to not try to go deep into every technology but stay curious about them because this new technology might be the solution to your problem of tomorrow.
Conclusion
Transitioning from Monolith to Microservices is very challenging. As mentioned in this article the complexity increases a lot because the whole process of software development must be known by the software engineer.
You must know about cloud providers, cloud services, container tools, infrastructure as code, monitoring tools to debug your code and check health, and automation to integrate, build, test, and deploy your services. You also must know multiple architectures to enhance performance and database paradigms.
Other than that you will encounter lots of code that weren’t common before, you will see container code, and you will have to pass tons of parameters to applications to run them locally. You will need to create lots of jobs (small programs that run periodically to solve a specific problem).
You will have to deal with security using SSL, Saml, certs, HTTPS, JWT, OAuth, OWASP, and many other concepts! It will be also very common for you to deal with Unix commands.
To help you with that there is the following article with good courses to help you to be a good software engineer and also be able to solve a vast range of software problems in the cloud era:
