Week 8 of #100DaysOfCode: Grinding for Exams

Introduction

Instead of building a new project, I decided to go back to the fundamentals. I spent most of the week learning more about the Spring Framework, especially concepts like Spring AOP, Dependency Injection, the IoC Container, Spring Security, logging, and software design principles.

I also spent a good part of the week preparing for my upcoming exams while staying consistent with my #100DaysOfCode challenge. Alongside that, I updated my CV, continued applying for backend roles, and even tried an AI-powered mock interview. Let's just say it was a good reminder that I still have a lot to improve when it comes to technical interviews.

Although I didn't ship a new project this week, I don't see it as a slow week. Understanding the concepts behind the framework I use every day is just as important as writing code. The better I understand how Spring works, the better I'll be able to build secure, scalable, and maintainable applications.

This week was less about showing what I built and more about strengthening the foundation I'm building on.

"The more I learn, the more I realize how much I don't know."

— Albert Einstein

Day 45: Moving from In-Memory to Database Authentication

On day 45, I continued learning Spring Security by moving from in-memory authentication to database-backed authentication.

What I Learned

• Created a user database for authentication
• Implemented a custom UserDetailsService
• Created a custom UserPrincipal by implementing the UserDetails interface
• Configured a DaoAuthenticationProvider
• Connected Spring Security to my user repository
• Learned more about how Spring Security retrieves user information and authenticates users behind the scenes

I'm still following a tutorial, but I'm trying to understand what is happening under the hood instead of simply getting the code to work.

Challenges I Faced

I ran into some issues while configuring Spring Security, particularly around version compatibility and the changes in newer versions of Spring Security. This helped me understand that the way Spring Security is configured can change between versions.

snippet of the code.

Day 46: Learning Spring AOP

Today, I learned how Spring AOP (Aspect-Oriented Programming) helps keep applications clean and maintainable.

What I Learned

• What Spring AOP is and why it is useful
• How cross-cutting concerns can be separated from business logic
• The Proxy Pattern in Spring
• The Decorator Pattern and how it relates to Spring AOP
• How Spring uses proxies to apply concerns such as logging, security, and transaction management without directly modifying business logic

The main idea I took away today is that not every piece of code belongs inside business logic. Concerns like logging, security, and transaction management can be handled separately using AOP, making applications easier to maintain and extend.

Today was mostly focused on understanding the concepts and design patterns behind Spring AOP. I didn't build anything practical yet, but understanding these concepts is helping me see how Spring works behind the scenes.

AOP process diagram

Day 47: Understanding Spring AOP Proxies

Today, I continued learning Spring AOP and explored how Spring uses proxies to implement Aspect-Oriented Programming behind the scenes.

What I Learned

• The difference between JDK Dynamic Proxy and CGLIB Proxy
• When Spring uses JDK proxies and when it uses CGLIB proxies
• How AOP helps solve code tangling
• How AOP helps solve code scattering
• How Spring AOP uses proxies to separate cross-cutting concerns from business logic

One thing I found particularly interesting is that Spring doesn't modify the original classes directly. Instead, it creates proxy objects that can intercept method calls and apply cross-cutting concerns such as logging, security, and transaction management without changing the business logic itself.

Challenges I Faced

I didn't encounter any major technical errors today. The main challenge was understanding how JDK Dynamic Proxies and CGLIB proxies work and how they fit into Spring AOP.

Day 48: Understanding Spring AOP

Today, I continued learning Spring AOP (Aspect-Oriented Programming) and gained a much better understanding of how Spring handles cross-cutting concerns behind the scenes while preparing for my exam.

What I Learned

• Why Spring AOP exists and the problems it solves
• Cross-cutting concerns, code tangling, and code scattering

• The five types of Spring AOP advice:

  • Before
  • After
  • After Returning
  • After Throwing
  • Around

• The relationship between Advice, Join Points, Pointcuts, and Aspects

• How weaving combines aspects with business logic using proxies

• How to define pointcuts with annotations to determine where advice should be applied

One thing I've realized is that Spring AOP isn't just about logging or security. It's about keeping business logic clean by separating concerns that would otherwise be repeated throughout an application.

Understanding what's happening behind the scenes has given me a much greater appreciation for how the Spring Framework is designed.

Challenges I Faced

I didn't encounter any major technical errors today. The main challenge was remembering how the different AOP concepts—especially advice, join points, pointcuts, aspects, and weaving—fit together.

Day 49: Getting Started with Spring JDBC

Today, I continued learning Spring JDBC and JdbcTemplate, focusing on how Spring simplifies database access.

What I Learned

• How Spring approaches data persistence
• The Template Design Pattern
• Problems with traditional JDBC
• How JdbcTemplate reduces boilerplate code
• How Spring handles data-access exceptions
• Different DataSource implementations
• The importance of database connection pooling
• Using the Builder Pattern to create an embedded data source

One thing I'm starting to understand is that Spring's abstractions aren't just there to make development easier. They help remove repetitive work and allow developers to focus more on the actual application logic.

Understanding the patterns behind these features is also helping me see how many of Spring's tools are designed.

Challenges I Faced

I didn't encounter any major technical errors today. The main challenge was understanding how the Template and Builder patterns fit into Spring's approach to database access.

Day 50: Halfway There

50 days down. 50 to go. 💙

Honestly, reaching Day 50 feels different.

When I started this challenge, I knew I wanted to learn, build, and become better at software engineering. But I don't think I fully understood how much work, confusion, frustration, and self-doubt would come with it.

There have been days when things made sense, days when I felt completely lost, and days when I wondered if I was actually improving. But somehow, I kept showing up.

What I Learned

• How the DAO pattern abstracts database access
• How JdbcTemplate simplifies database operations
• How RowMapper, RowCallbackHandler, and ResultSetExtractor are used when working with query results
• Best practices for configuring and using Spring JDBC

Challenges I Faced

I didn't encounter any major technical errors today. The main focus was understanding how these different components work together and why Spring provides these abstractions in the first place.

Halfway Reflection

More than anything, Day 50 is a reminder that I'm still on the journey.

I still have a lot to learn. There are things I struggle to remember, concepts I have to revisit, and areas where I don't feel confident yet. But I'm beginning to understand more than I did when I started.

I'm also really grateful for the people who have supported me along the way.

To everyone who has liked my posts, commented, shared them, encouraged me, or simply followed my journey—thank you. I genuinely appreciate it.

And a special thank you to my mentor, Habibulah Oyero, for the guidance, encouragement, and support that have helped me get this far. I'm truly grateful for everything you've done for me.

I'm halfway through the challenge, but the journey is far from over.

I pray God continues to guide me, give me strength, and lead me to the right opportunities as I keep putting in the work.

For now, I'll keep learning, building, making mistakes, and trying again.

50 days down. 50 more to go. Let's keep building. 💙

Goals for Week 9

With my exams almost behind me, I'm looking forward to shifting some of my focus back to building, improving my technical skills, and preparing for backend engineering opportunities.

Here are my goals for Week 9:

• Practice LeetCode consistently to improve my problem-solving skills
• Do more mock technical interviews to build my confidence
• Continue applying for backend engineering roles
• Continue learning Spring Security and complete database-backed authentication
• Build practical examples around the Spring concepts I've been studying
• Review core Data Structures and Algorithms for coding interviews
• Resume learning Python alongside my Java backend journey
• Improve my existing projects whenever I have the time
• Stay consistent with #100DaysOfCode and continue documenting what I learn

This week, I went deeper into Spring AOP, dependency injection, Spring Security, logging, and Spring JDBC. A lot of what I learned wasn't immediately visible in an application, but it helped me understand more about what happens behind the scenes.

As my exams come to an end, I'm excited to get back to building and also start putting more effort into interview preparation.

I want to become better at solving problems, writing clean code, understanding the systems I build, and most importantly, being able to explain my thought process when I'm in an interview.

I'm still learning. I'm still figuring things out. But I'm making progress, one day at a time.

If you're also learning, building, or growing in tech, I'd love to connect and follow your journey too.

Let's keep building. 💙

LinkedIn:
https://www.linkedin.com/in/onatade-abdulmajeed/

X (Twitter):
https://x.com/spider337761