DEV Community: Beching Rexzy Bate

The Power of Aspects (AOP) 😂🔥

Beching Rexzy Bate — Thu, 05 Nov 2026 14:21:39 +0000

Spring, what exactly are you teaching me? Are we still building applications or learning how to hack them? 😂

I've been exploring Aspect-Oriented Programming (AOP), and I think I've found one of the coolest things in Spring so far.

Here's what caught my attention.

Imagine sending a request to a method, expecting it to execute normally. But somewhere in the background, something intercepts that call.

It can access the information you're sending, change it before it reaches the actual method, allow the method to execute, intercept the result and even modify that before it gets back to you.

And the craziest part? The original caller has absolutely no idea this happened!

It's almost like sending a message to someone, only for an unseen middleman to intercept it, change its contents, deliver it, then alter the reply before forwarding it to you. 😂

In Spring, that middleman is made possible through an Aspect and a Proxy.

And just when I thought things couldn't get more interesting, I met some of the terminology:

Aspect: The separate piece of code responsible for this additional behaviour.
Advice: The actual action the aspect performs. Wait, so code can give advice now? 😂
Pointcut: Defines which method calls should be intercepted. Basically, it tells the aspect where to watch.
Weaving: The process of connecting the aspect's behaviour to the application.

I won't lie, the first time I understood how much control an aspect could have over a method call, it felt like I had discovered a new way to manipulate an application without touching the original method.

That's some serious power!

Still exploring Spring, but this was definitely one of those concepts that made me stop and appreciate what happens behind the scenes.

Java #SpringFramework #SpringAOP #SoftwareEngineering #LearningInPublic

Tech Is Moving Fast. Can Someone Tell the Beginners What's Going On? 😂

Beching Rexzy Bate — Thu, 05 Nov 2026 03:08:42 +0000

I sometimes visit DEV Community with the intention of learning something new.

And I always find something new. The problem is that I don't always understand what I have found. 😂

I open an article, read the title, and pause for a moment.

Then I read the introduction. I pause again.

By the time I reach the second paragraph, I am already questioning some of my life choices.

What exactly is this? Is this still technology? Is this something developers do? Is it a tool? A framework? A new way of thinking? Or have I somehow missed an entire chapter of the tech world?

And the funny thing is, the authors are not necessarily doing anything wrong. Some of these articles are genuinely interesting. People are building incredible things, exploring new technologies and solving problems in ways I never imagined.

But sometimes, I look at what they are discussing and realise that I don't even know that such a thing exists.

I came to learn something, but somehow, I have discovered five new things I need to learn before I can understand the first one.

And this isn't only about programming. Technology is a very wide world. There is cloud computing, cybersecurity, artificial intelligence, networking, DevOps, data engineering, hardware, and so many other areas. Every corner seems to have its own language, tools and endless discoveries.

You learn one thing and suddenly discover that it has ten other things connected to it.

Sometimes, it feels like everybody received a memo about what is happening in tech, except me. 😂

Then comes the bigger question:

How long does it actually take to become comfortable in this field?

Because the more I learn, the more I realise how much I don't know.

I guess that is part of the journey. There is so much happening in technology that nobody can know everything. Even the things that seem strange today might become familiar tomorrow.

For now, I am still reading, learning, experimenting and occasionally staring at article titles for longer than I should.

Tech may not be making the beginner journey easy, but we keep moving.

One day, I am sure we will graduate from beginners to pros, provided we don't give up along the way.

Until then, please let me finish understanding one strange tech term before introducing me to another one. 😂

When Scripting Saves the Day... After Almost Deleting System32🥲

Beching Rexzy Bate — Mon, 02 Nov 2026 23:12:50 +0000

Let's be real. There are two kinds of developers: those who have a perfectly organized file structure, and the rest of us whose computers look like a chaotic digital junk drawer.

I was firmly in the latter camp. My hard drive was so messy it caused me actual emotional damage just thinking about organizing it. We're talking nested folders inside nested folders, download files from years ago next to crucial system files, and random screenshots floating in the void.

Every time I looked at it, I just wanted to close the lid. The task was monumental. But the engineering voice in my head kept whispering, "Automate it. This is literally what computers are for."

The First Script: The Great Filter

I finally broke down and wrote a simple Node.js utility. It was basic, but it felt like absolute magic.

You define your source, you define the destinations based on file extensions (.jpg moves to Pictures, .pdf moves to Documents, etc.).

Here is the functional core that brought me immediate salvation in a single execution:

In a split second, my main folder transformed from a crime scene into a structured system. All my PDFs were in Documents. My old files were safely categorized. It was the moment the true beauty of automation finally clicked for me.

The Near-Death Experience (Why You Script with Care)

But the journey wasn't over. My first script was too safe—it didn't touch my Desktop or my Downloads folder, which was where the real chaos lived.

So, being a developer, I decided to scale up the script. I added recursive logic to sweep everything. This is where things went wrong.

I almost tanked my system. In my eagerness to sort my files, my script started sweeping up crucial directory paths because I hadn't properly refined my recursion boundaries.

My heart literally stopped.

Why You ALWAYS Log Your Output

This is the key lesson: I didn't lose my mind (or my files) because I had excellent logging output.

While the catastrophic script was running, my terminal was streaming successful (and terrifying) file moves. When the horror subsided, I didn't panic. I analyzed the logs. I knew exactly where every single file had been moved to.

Instead of panicking, the log file gave me the roadmap. I used the existing script logic, flipped the source and destination paths, and used my logs as the index to put everything back. It was a stressful but incredible lesson on why logging is NOT an afterthought; it’s your safety net.

Conclusion: The "Script First" Mindset

Now that I've organized my system (and successfully reversed my self-inflicted disaster), my entire workflow has changed. Before I do any repetitive digital task, I ask myself one question:

Can there be a script for this?

Yes, you can do things faster with automation, but you also learn the hard, fun, and beautiful way about how file systems actually operate when things go wrong!

From Core Java to Spring Boot: When the Code Works, but the "Big Picture" is Still Loading

Beching Rexzy Bate — Mon, 02 Nov 2026 22:47:13 +0000

Learning software engineering is an absolute ride. Some days you feel like your coding IQ is increasing exponentially; other days, you wish you were just born with all the skills already downloaded into your brain!

Lately, I’ve been making the transition from core Java OOP concepts into Spring Boot.

I get the concepts… but at the same time, I don’t quite get them yet. Funny, right?

💻 Where I’m At Right Now

I've been following along with structured literature, working through hands-on code examples line by line. Right now, I'm exploring Spring Context configurations, * lazy * initialization (*@lazy), *component stereotypes, and fetching beans dynamically via ApplicationContext.

🧠 The "Real-World Project" Gap

Even though the book examples run smoothly, I find myself pausing and asking:

"How does this actually map to a real, production-ready system?"

Because textbook exercises are isolated, it can be tricky to discern why a specific design choice is made until you’re building something substantial from scratch. I suspect the missing bridge is simply experience—I haven't built a massive end-to-end production application in Spring yet.

Despite the hurdles, the process has been genuinely fun. Watching how framework abstractions work after months of pure Java feels like discovering magic spells.

❓ To the Spring Devs out there: What was your turning point?

For anyone who has crossed this bridge before:

When did the "Spring Way" of thinking finally click for you? Was it during your first full project, or did a specific concept make it all fall into place?

What small starter project would you recommend for bridging the gap between textbook examples and real-world backend architecture?

If you're currently in the middle of learning Spring too, let me know how your journey is going in the comments below!

Transitioning from Core Java to Spring Boot: How did you handle the mental shift?

Beching Rexzy Bate — Tue, 20 Oct 2026 19:45:11 +0000

After spending 8 months getting my hands dirty with core Java fundamentals—multithreading, generic data structures, and OOP—I'm officially stepping into Spring Boot, Spring MVC, and Thymeleaf.

Going from manually managing objects and low-level code to letting a framework handle bean lifecycles and dependency injection feels like a completely different mindset.

For the Java devs here: How did you make the mental jump from pure core Java to Spring? Did you prefer reading a comprehensive book or building small project iterations first?

What kind of small project are you planning to build first with Spring Boot and Thymeleaf once you get started?