How to become a production ready developer?
In these days sticking to a single technology / programming language / tool is not enough for a developer. There are so many things to consider, especially in the microservice’s world.
This might make developers freak.
As a software developer in my daily job I am handling different stuffs like designin architecture, writing code, testing it, writing CI/CD pipelines, creating alerts according to logs or events, monitoring the app etc..
In this article I am aiming to enlighten the new developers or the ones who does not involved in multi-tech stack.
What is the requirements of developing applications and deploying to production?
What are some concepts to follow?
- Unit Tests (Coding)
We need to develop applications in a testable matter. All the business requirements and features must be testable. With unit testing, we prove that our code works respecting to what business said.
2. Domain Driven Design (Architecture)
To talking the same language in business persons we need to develop a language. Also to build extensible, testable, understandable application we need some abstractions&rules to follow. In DDD we can provide a clean solution to complex business domains.
I recommend the red book of Vaughn Vernon: “Implementing Domain Driven Design”.
3. Clean Code Practices (Coding)
We need to follow clean code practices to write clean, understandable, readable code.
4. Integration&Automation Tests (Testing)
We need to prove that our application can work without trouble with 3rd party applications. Also we want to test our application from outside point of view. And we want to avoid doing that manually every time for any change occurs. So we write integration&automation tests to automate that process.
5. Consumer Driven Contract Tests (Testing)
How do we sure about our consumers will not affected when we made a change to an endpoint in our rest api?
What if we change a field’s name which is used by a consumer by accidentally?
CDC tests to rescue. We and our consumers writes CDC tests and run those tests in pipeline to prevent deploying any breaking change.
Take a look to project pact: https://docs.pact.io
6. Hexagonal Architecture & Ports Adapters & CQRS (Architecture)
We need to provide extensibility and a well abstraction to our project. Abstracting application/domain/infrastructure/api levels of our project is much more important compared to what framework we used. Here is hexagonal architecture and port&adapters comes into view.
Also we might want to scale our application’s read and write parts separately. Or we want to divide/abstract that responsibility in the code. Here is what CQRS tells us.
Take a look for more information: https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/
7. Containers & Docker (Devops)
We can dive into containers from a higher level with Docker. Mostly used de-facto standart in container tech.
Also there are some other tools to build containers like buildah & podman.
8. CI/CD Pipelines (Devops)
We need to automate our test / build / deploy steps of our applications.
With using CI/CD tools (Jenkins, Gitlab etc.) we can achieve this.
9. Kubernetes (Devops)
Well K8S is the de-facto standart for container orchestration. We can run/scale/discover our services with kubernetes.
As a developer we need to be familiar with it to understand the environment which our application works on.
10. Logging (Monitoring)
Logs are the one of the way to help us to understand our application’s behavior. With a good logging system we can catch unexpected behaviors/errors and take actions to them.
There are many different logging techs like ELK stack.
For example, we are trying to follow 12 factor app strategy. Our applications does not aware of the underlying tech about logging. All our microservices print their logs to stdout and we collect it with fluentbit/fluentd in kubernetes. With this way we are abstracting the logging technology from applications. We can switch the log storage without affecting applications.
Softwares are alive systems. They need to be watched all the time. To determine any anomaly (like high resource usage, total requests, response times) and optimize those we need to keep track it.
There are tools like NewRelic, Jaeger, Elastic APM which helps us to monitor applications.
12. IaC (Devops)
Infrastructure as code help us to automate any machine provision & configuration process. Tools like terraform, ansible, chef, puppet, vagrant, docker help us to achieve IaC. We can write our environment in a terraform/ansible as code and we automatically run those in a pipeline to bootstrap the environment.
13. Message Brokers (Architecture)
We might want to design our service communications in an async way. Mostly we do it as a performance optimization. For example, sending information mail end of a process can be async. So we can separate those services and provide communication between separated services with a message broker.
There are some popular tools like RabbitMQ, ActiveMQ, Kafka, Aws Sqs etc.
14. Databases & Cache (Storage)
We use storage systems. So we need to know how to use them. Underlying storage systems might affect our data structure. Wrongly designed schemas affects performance of the application.
How to store and retrieve data? Is there a faster way to access data? Do I need to do db calls all the time? We need to be able to answer these questions.
When we using a database (sql/nosql), we need to take a look how to index data, how to apply right schema, how to retrieve it etc.
We also might need to take the overhead from db and use a cache solution. We can cache frequently accessed data.
I am stopping here and wishing you to enjoy while reading.
This list contains the first things that comes into my mind. There are so many other parts to consider while developing an application. Like eventually consistency, event sourcing, circuit breaker, retries, distributed locks, saga, state machines etc..
If you have any suggestion/addition to list write it on comments.
You can follow me on: