Introduction
This week was another challenging but rewarding part of my #100DaysOfCode journey.
I started the week by learning about Docker and containerized Microservices, exploring how containers differ from Virtual Machines, how Docker images and containers work, and how Docker helps package applications and their dependencies consistently.
I then moved into scaling Dockerized Microservices, where I learned about autoscaling, container orchestration, Apache Mesos, Marathon, resource allocation, and managing Microservices at scale.
One of the biggest highlights of the week was completing my Building Spring with Microservices course and writing the exam. After months of learning topics such as Spring Boot, Spring Cloud, Microservices, reactive programming, service discovery, API gateways, logging, monitoring, Docker, and scaling, I was happy to finish the course with a score of 85%.
After completing the course, I started a new chapter by learning software testing with JUnit 5. I began with the fundamentals of software quality, Verification and Validation, software defects, testing levels, static analysis, and the role of JUnit in Java testing.
This week reminded me that backend engineering goes beyond writing code. It also involves understanding how applications are packaged, deployed, scaled, tested, and maintained reliably.
I'm glad to have completed one major learning milestone and started another area that will help me become a better engineer.
Still learning. Still building. Still showing up. š
"Great things are done by a series of small things brought together."
ā Vincent van Gogh
Day 80: Beginning Docker and Containerized Microservices
On Day 80, I started Chapter 14, Containerizing Microservices with Docker.
What I Learned
- What containers are and how they provide operating system virtualization
- The difference between Virtual Machines (VMs) and containers
- The benefits of containers, including scalability, portability, reusability, and immutability
- How containers support Microservices architecture
- An introduction to Docker as a platform for building, shipping, and running containers
- The two main Docker components: the Docker Daemon and the Docker Client
One thing that became much clearer to me was the difference between VMs and containers. While VMs provide isolation through a guest operating system, containers are much lighter because they share the host operating system. This makes them faster to start and more efficient for running Microservices.
I also started to understand why containers are useful when working with Microservices. Instead of worrying about differences between environments, applications and their dependencies can be packaged together and run consistently.
Day 81: Containerizing Microservices with Docker
On Day 81, I continued learning about Docker and completed the chapter on Containerizing Microservices with Docker.
What I Learned
- Docker Images ā read-only templates containing the OS libraries, applications, and their dependencies
- Docker Containers ā running instances of Docker images
- Docker Registry ā where Docker images are published and downloaded
- Docker Hub ā Docker's central registry
- Docker Trusted Registry (DTR) ā used for setting up local or on-premise registries
- Dockerfiles ā files containing instructions for building Docker images
Understanding these fundamentals is helping me see how Docker packages applications and their dependencies so they can be built, shipped, and run consistently.
With this chapter completed, I now have a better understanding of the role Docker plays in containerizing and deploying Microservices.
Day 82: Scaling Dockerized Microservices with Mesos and Marathon
On Day 82, I started Chapter 15, Scaling Dockerized Microservices with Mesos and Marathon.
What I Learned
- Different approaches to autoscaling
- Scaling based on resource usage, time periods, queue length, and business parameters
- Predictive autoscaling
- Why Docker alone isn't enough for managing Microservices at scale
- The importance of container orchestration
- How orchestration helps with resource allocation, deployments, scalability, health, and service availability
- Different orchestration tools, including Docker Swarm, Kubernetes, Mesos, Marathon, Nomad, and Fleet
- Apache Mesos architecture and its Master, Agents, ZooKeeper, Scheduler, and Executor
- Marathon and how it manages long-running applications and Docker containers
One thing that stood out to me is that as the number of Microservices grows, manually managing containers becomes difficult. Container orchestration provides the abstraction and automation needed to manage these systems more efficiently.
This chapter also helped me understand that scaling isn't only about running more containers. There needs to be a system that can manage resources, monitor services, handle failures, and make sure the required number of instances are running.
Day 83/100
Today, I officially completed my Building Spring with Microservices course and wrote my exam.
I scored 85%.
A few months ago, when I started learning and practicing Spring concepts, I thought there was too much for me to know. Microservices, Spring Boot, Spring Cloud, reactive programming, service discovery, API gateways, logging, monitoring, Docker, scaling, and a lot more.
There were days when learning felt tiring. I had to go back, reread concepts, practice them, fix bugs, and prepare seriously for the exam.
Today, seeing 85% on that result reminded me that the effort was worth it.
Iām really happy to finally say that Iām done with the course.
I'm grateful to Habibulah Oyero and everyone following along for the support, guidance, and encouragement throughout this journey. Your push to keep learning, building, and sharing my progress has made a real difference.
This is another milestone in my journey to becoming a better backend engineer.
I'm not stopping here. There are still plenty of things I need to learn, build, break, fix, and improve.
Day 84/100
New chapter, new area to learn.
Today, I started Mastering Software Testing with JUnit 5.
I started with the basics of software quality, quality engineering, Verification and Validation, software defects, and software testing.
What I Learned
- Quality Planning, Quality Assurance, and Post-QA
- Verification & Validation
- The software defect chain: Error ā Fault ā Failure ā Incidence
- Testing levels: Unit, Integration, System, and Acceptance
- Black-box, White-box, and Grey-box testing
After spending the last few weeks learning about Microservices and distributed systems, I'm looking forward to getting deeper into software testing and understanding how to write better and more reliable code.
Day 85: Going Deeper into Software Testing with JUnit 5
On Day 85, I continued learning Mastering Software Testing with JUnit 5.
I went deeper into the first chapter, focusing on software quality, Verification and Validation (V&V), software testing, static analysis, and the role of JUnit in Java testing.
I also took a quiz on the chapter to test how well I understood what I had studied.
What I Learned
- Software quality
- Verification and Validation (V&V)
- Software testing
- Static analysis
- The role of JUnit in Java testing
- The importance of testing software against its requirements and expected behavior
One thing that stood out to me is that software testing isn't just about finding bugs. It's part of the bigger process of building software that actually meets its requirements and user expectations.
I'm gradually getting a deeper understanding of software testing and how it fits into the software development process.
Goals for Week 14
As I move into Week 14, my main focus will be on continuing my learning journey with software testing and JUnit 5, while also strengthening the backend concepts I have already covered.
Here are my goals for Week 14:
- Continue learning Software Testing with JUnit 5
- Deepen my understanding of software quality, testing concepts, and test automation
- Start applying JUnit 5 concepts through practical examples
- Continue reviewing and strengthening my Java and backend development knowledge
- Practice LeetCode when I have available time
- Continue applying for backend engineering opportunities
- Stay consistent with #100DaysOfCode and continue documenting my progress
This week, I want to focus on building a stronger understanding of software testing and writing better, more reliable Java code.
After completing my Microservices course, I'm looking forward to applying what I've learned while continuing to develop the skills I need to become a better backend engineer.
Still learning. Still building. Still showing up. š
Connect With Me
LinkedIn:
https://www.linkedin.com/in/onatade-abdulmajeed/
X (Twitter):
Top comments (0)