Okay, so I kept hearing this name, Stefan Jankovic, mentioned in some dev circles online. Not like, super famous, but popping up here and there, usually tied to some specific way of organizing code or tackling problems. It got me thinking, you know? My own stuff felt a bit messy lately, maybe there was something to learn.
So, I decided, alright, let’s see what this is about. I carved out some time last weekend. First thing, I had to figure out what people actually meant when they mentioned his approach. Wasn’t straightforward, no official website or anything obvious like that. Just scattered forum posts, maybe a couple of old blog entries discussing his techniques.
Digging In
I spent a good few hours just reading, trying to piece it together. From what I gathered, the core idea seemed to be about really aggressive decoupling. Like, making components super independent, more than I usually would. And some specific ideas about handling state changes, trying to minimize side effects everywhere.
- Step 1: Found some examples people claimed were inspired by him. Mostly snippets on places like GitHub gists or old forum threads.
- Step 2: Tried to understand the pattern. It looked like it involved using more message queues or event buses internally, even for smaller applications.
- Step 3: Picked a small utility script I wrote a while back. Nothing critical, good for experimenting.
- Step 4: Started refactoring. Ripped out some direct function calls. Replaced them with a simple event emitter system I cobbled together based on the examples.
The Process
Honestly, it felt weird at first. Like I was adding extra steps for no reason. Passing messages around instead of just calling a function seemed like overkill for my little script. It definitely made the code longer. Took me most of Saturday afternoon just to rework one part of the script.
Then I ran it. It worked, which was good. The setup felt a bit more complex, though. Debugging seemed like it might be trickier, trying to trace events instead of direct calls.
But here’s the thing: when I needed to add a small feature later – just logging one specific action to a file – it was surprisingly easy. I just added another listener for that event. Didn’t have to touch the original code that triggered the action. That part felt… clean. I’ll give it that.
Final Thoughts (For Now)
So, yeah. That was my little experiment trying to apply what I think is the ‘Stefan Jankovic’ way, based on my digging. Am I a total convert? Not yet. It felt heavy for my simple script. But I can see how maybe, just maybe, on a bigger project with more moving parts, this aggressive decoupling might actually save some headaches down the line. It forces you to think about interactions more explicitly.
I haven’t fully formed my opinion. Need to try it on something slightly bigger, I guess. See if the benefits outweigh the initial complexity and verbosity. It’s definitely given me something to chew on, thinking about how different parts of my code talk to each other.
