Search
175 results for “oskardudycz”
-
Folks, the new docs section on writing read models in #Emmett just arrived! Check it till it's fresh, and tell me how you like it!
https://event-driven-io.github.io/emmett/getting-started.html#read-models
It's a first draft, more to come and needs to be documented, but baby steps 🙂
We'll get there!
-
Folks, the new docs section on writing read models in #Emmett just arrived! Check it till it's fresh, and tell me how you like it!
https://event-driven-io.github.io/emmett/getting-started.html#read-models
It's a first draft, more to come and needs to be documented, but baby steps 🙂
We'll get there!
-
In distributed systems, we face a fundamental tension between module communication and module autonomy. Our modules need to exchange information and coordinate actions, yet we want each module to evolve independently without forcing changes across the entire system.
This tension becomes evident in event-driven architectures, where modules communicate through events and messages.
Consider a typical e-commerce platform. The payment module needs to process requests from orders, handle reimbursements, manage subscriptions, and potentially deal with dozens of other payment scenarios.
Each connection point between modules represents a potential coupling that can ripple through the system when requirements change.
The traditional approach involves modules directly referencing each other through event types, API endpoints, or shared data structures.
This creates a web of dependencies where adding a new module or changing an existing one requires coordinated updates across multiple teams.
What if we could enable modules to communicate without knowing about each other's existence?
What if a payment module could process requests from any source without being programmed to handle specific scenarios?
I've explored in the latest #ArchitectureWeekly how predictable identifiers, specifically Uniform Resource Names (URNs), provide an elegant solution to this challenge.
The key insight is that identity can carry meaning without creating coupling. URNs provide a standardised way to structure this identity, enabling infrastructure-level routing while maintaining module independence.
The payment module could process generic payment requests, inverting the dependency and publishing responses using the correlation ID for routing. It never needs to know whether a payment is for an order, reimbursement, or subscription.
Read more in https://www.architecture-weekly.com/p/predictable-identifiers-enabling
Are you using such an approach in your systems?
-
I've been facilitating the #EventStorming sessions for years now, and something keeps catching my attention.
While teams naturally focus on mapping out those orange event sticky notes (the backbone of any EventStorming session), they often underestimate the power of two critical elements: Hot Spots and Notes.
What I value most about Hot Spots and Notes isn't just how they improve workshops - it's how they change team culture around uncertainty.
In technical discussions, we often feel pressure to know everything immediately.
Hot Spots create permission to say, "I don't know yet" while still making progress. They transform uncertainties from conversation-killers into clearly defined next steps.
I've seen teams evolve from hiding what they don't know to actively hunting for uncertainties as valuable information. Questions become assets rather than liabilities.
If you're incorporating EventStorming into your toolkit, don't underestimate these powerful elements. They might not get as much attention as domain events, but in my experience, they often separate a productive modelling session from a frustrating stalemate.
Read more in the latest #ArchitectureWeekly: https://www.architecture-weekly.com/p/the-underestimated-power-of-hot-spots
-
Sounds like #ArchitectureWeekly just passed 10 000 subscribers. Nice! 🤟😎
-
Have you heard a surgeon say: "I won't sterilise my tools, as the patient won't let me"?
I haven't, but I have heard multiple times: "Business won't let us add unit tests."
As this grinds my gears, I decided to write my take on why we tell those lies to ourselves. I think that it's more about us avoiding accountability and dodging our duties than about mischievous business people.
Read more in the latest #ArchitectureWeekly: https://www.architecture-weekly.com/p/business-wont-let-me-and-other-lies
What's your take on that?
-
Object-oriented or relational? Why not both?
For many years, we tried to fit the business data into a normalised table structure. We used Object-Relational Mappers, which was a constant battle on how to map unfitting models.
Then document databases like MongoDB came along and got traffic.
Still, many people wanted guarantees they had in relational databases, they also wanted to reuse muscle memory related to operations and other tooling.
Now we have the choice as we have #JSONB data type implemented by #PostgreSQL and then by MySQL, SQLite.
The B in JSONB stands for binary. It looks like a JSON, it quacks like a JSON, but it's not JSON. And thanks to that, it's powerful.
When you're storing JSON data in JSONB, it's parsed, tokenised, and stored in a tree-like structure. Types are preserved, and a hierarchical structure is also preserved, and thanks to that, you can index it and efficiently query it.
I'm super happy that in recent years, I have had the opportunity to use Postgresql and JSONB, first in Marten and now in Pongo. I didn't look back. JSONB has its cons, but for most typical line-of-business applications, they're negligible.
I finally wrote an intro in #ArchitectureWeekly about how JSONB works, check it, tell me how you liked it and share with your friends!
And most importantly, play with it on your own 😊
https://www.architecture-weekly.com/p/postgresql-jsonb-powerful-storage
-
The pendulum swung back! Now, the "modular monolith first" is the best advice. But is it?
Every few years, our industry rallies around a new architectural approach that promises to solve all our problems. A few years ago, we all wanted to be micro and distributed. Microservices for the win!
Now, we hear the “modular monolith first!”.
It sounds great in theory but can fall short in practice. In practice, too often:
- module boundaries erode,
- resource isolation is absent,
- promised "easy split" rarely happens,
- ease of deployment is not so easy, as CI/CD tooling is not existing or absent.I was a bit fed up with the blank advice to go monolith first and covered stuff that, too often, is missed by the folks overselling this idea.
Read more in the latest #ArchitectureWeekly: https://www.architecture-weekly.com/p/monolith-first-are-you-sure
I’m not against monolith-first. Moreover, I agree with the general principles, but I wanted to debunk some myths around it.
The modular monolith isn't a free lunch.
It’s not precise to say:
“If you cannot deal with monolith, microservices won’t work for you!”.
The actual phrase should be:
"If you can’t deal with modularity, then neither monoliths nor microservices will work for you."
If you try to cheat and select modulith-first to cheat using a simplistic solution, it won’t help you; you will probably end up with a big ball of mud.
Monolith-first can give you a gradual process of reaching maturity, but you need to plan it and consider that the DevOps process related to it and tooling is not as simple and mature as glossed.
So, if you’re considering whether to go with microservices-first or monolith-first, you may be thinking the wrong way.
You should go Modular-First and then think about your deployment strategy.
What are your thoughts?
-
💣 Boom here comes the big news! I made the #ArchitectureWeekly a fully free newsletter. Yes, all the past articles and videos are free. Why did I do it?
https://www.architecture-weekly.com/p/whole-architecture-weekly-content
I believe that all of that gives you more content than a lot of books or paid online courses.
Why did I do it? Am I mad? What’s the catch?
In past years, I delivered many unique materials. I also increased the number of subscribers, both paid and regular ones. Preparing the type of content that I try to deliver each week quality content, takes time and focus.
I still want to do that and produce new articles, but I decrease the pressure to do full-length and deep dives each week—sometimes even on weekends. And I’m not sure how about you, but I prefer to spend weekends with my family.
The number of paid subscribers grew, but still insufficient to fully focus on Architecture Weekly. That’s fine, as I have other work, such as consultancy and training, open source work, and contracts.
I believe that making the Architecture Weekly free newsletter should free some time for me, reduce the pressure I put on myself and let me focus on other stuff.
I still plan to deliver similar content as I did, keeping the weekly cadence, maybe in a slightly different form, or changing it to every other week later on. We’ll see.
So if you worry, don’t. I don’t plan to shut it down, but do it more for fun than profit. Quality should still be here, but maybe a bit lightweight form.
I would appreciate it if you shared the news with your friends, so they could also benefit from those free materials. I believe they’re worth it.
What are your thoughts?
-
So you want to break down monolith? Read that first. The obvious advice is to use the Strangler Fig pattern, and gradually replace the old code, until it's fully brand new.
Let me tell you something: your monolith will survive. Maybe partially, but it will. I haven't seen a complete monolith migration succeed.
Most were left in the middle of transition after going far above the planned time for rewrite.
Some finished the migration, but replaced the old legacy with the new legacy after rushing the deadline.
Some didn’t even manage those phases, as they sunk product and budget and were thrown away.
So, the safe assumption is that some part of the old system will remain and continue running.
After doing and observing numerous breaking-down-legacy-monolith operations, I've seen a clear pattern: teams fixated on architectural purity generally fail, while those focused on business value succeed.
The most effective migrations aren't driven by trendy tech or eliminating monoliths completely. They start with specific business needs - faster delivery of high-value features, better resilience in critical components, or enabling team independence.
Here's what I've found works consistently:
- focus on the features that extraction makes sense business-wise,
- define measurable business metrics before starting, not just vague technical goals
- be skeptical of customer feedback that isn't backed by behavior data,
- migrate in small vertical slices, learning and adjusting as you go,
- of course do strangler fig eventually.Most systems benefit from a pragmatic architectural mix. Some components genuinely need to be independent services, while others work perfectly in a monolith. Some may not fit perfectly but:
- work well enough,
- are changed rarely or
- are not a priority for business,
so why change them?Architecture should serve the business, not the other way around. Read the full detailed guide in the latest #ArchitectureWeekly.
Also, share your failed and successful migration strategy with me!
https://www.architecture-weekly.com/p/so-you-want-to-break-down-monolith
-
🎉 Small step, but big milestone for #Emmett, I just released the first version of async projections for #PostgreSQL!
Check more in the release notes: https://github.com/event-driven-io/emmett/releases/tag/0.31.0
-
🎉 Small step, but big milestone for #Emmett, I just released the first version of async projections for #PostgreSQL!
Check more in the release notes: https://github.com/event-driven-io/emmett/releases/tag/0.31.0
-
🎉 Small step, but big milestone for #Emmett, I just released the first version of async projections for #PostgreSQL!
Check more in the release notes: https://github.com/event-driven-io/emmett/releases/tag/0.31.0
-
🎉 Small step, but big milestone for #Emmett, I just released the first version of async projections for #PostgreSQL!
Check more in the release notes: https://github.com/event-driven-io/emmett/releases/tag/0.31.0
-
🎉 Small step, but big milestone for #Emmett, I just released the first version of async projections for #PostgreSQL!
Check more in the release notes: https://github.com/event-driven-io/emmett/releases/tag/0.31.0
-
Let’s say it’s Friday. Not party Friday, but Black Friday. You’re working on a busy e-commerce system that handles thousands of orders per minute. Suddenly, the service responsible for billing processing crashes. Until it recovers, new orders are piling up. How do you resume processing after the service restart?
Typically, you use the messaging system to accept incoming requests and then process them gradually. Messaging systems have durable storage capabilities to keep messages until they’re delivered. Kafka can even keep them longer with a defined retention policy.
If we’re using Kafka, when the service restarts, it can resubscribe to the topic. But which messages should we process?
One naive approach to ensure consistency might be reprocessing messages from the topic's earliest position. That might prevent missed events, but it could also lead to a massive backlog of replayed data—and a serious risk of double processing. Would you really want to read every message on the topic from the very beginning, risking duplicate charges and triggering actions that have already been handled? Wouldn’t it be better to pick up exactly where you left off, with minimal overhead and no guesswork about what you’ve already handled?
Not surprisingly, that’s what Kafka does: it has built-in offset tracking. It does it through internal topic and stores each offset change as a separate messages. Why does it do it this way? Wouldn't be simpler to just store in database the latest position?
That and more I discussed in the latest #ArchitectureWeekly.
Offset tracking may seem like a detail, but understanding it can be critical for smooth message processing. Check to learn more about internals, but also how other tools are dealing with it.
As always, we take a specific tool and try to extend it to the wide architecture level.
See more in 👇 and tell me your thoughts!
https://www.architecture-weekly.com/p/how-does-kafka-know-what-was-the
-
So I just closed 150th PR to #Emmett. Nice milestone 🙂🎉
Also I did 2 releases recently driven by community changes.
Steadily, step by step bootstrapping the project with still small but vibrant community.
Check more in: https://github.com/event-driven-io/emmett
-
So I just closed 150th PR to #Emmett. Nice milestone 🙂🎉
Also I did 2 releases recently driven by community changes.
Steadily, step by step bootstrapping the project with still small but vibrant community.
Check more in: https://github.com/event-driven-io/emmett
-
So I just closed 150th PR to #Emmett. Nice milestone 🙂🎉
Also I did 2 releases recently driven by community changes.
Steadily, step by step bootstrapping the project with still small but vibrant community.
Check more in: https://github.com/event-driven-io/emmett