Eventuous — the first year
I started working on Eventuous, a set of libraries for .NET that help people to start building event-sourced systems, in January 2021. Fifteen months ago, on 25 March 2021, the first version (0.1.0) found its way to NuGet. What happened between then and now?
As I write this post, Eventuous got 240 stars and 34 forks on GitHub. Not a lot, some might say, but not bad if you ask me. NuGet packages have close to 60K all-time downloads count, which indicates that quite a few are using it.
I had several conversations with people from around the globe who use Eventuous for their production systems, to build their first event-sourced application as a proof of concept, or to learn about Event Sourcing. Overall, the feedback is very positive. I talked to someone who has worked with .NET since version 1.1 but mainly built layered applications with SQL-based persistence. I have to say that his code impressed me. It all looked just fine, and I could point to just a couple of things I would change. He used the sample app, and it seems to be a good sample, as it’s not hard to amend it to your own domain.
Eventuous evolved. Driven by the simple principle “build stuff that you need”, it got messaging components, some cloud-native infrastructure support like Google PubSub, and more advanced things like partitioned subscriptions and all-over observability with built-in OpenTelemetry support. All those things proved useful and loved, so there’s little to no waste in the codebase, at least for now.
I delivered a few talks about Eventuous, online and offline. As usual, the talk’s success’ foundation is to match the expectations of the speaker and the audience. I don’t think my talk at NDC was very successful as I felt that most of the people wanted to know what Event Sourcing is. That wasn’t my goal; I was trying to show how easy the implementation might be if they use a proper tool, expecting the audience to know the basics. Still, some people reached out later and thanked me for the talk, as they were exactly the people I wanted to deliver my message to.
As I go to conferences mostly to meet and talk to people, DDD Europe 2022 was a success for me. After talking for almost an hour with Jérémie Chassaing, I made some changes, like ditching the aggregate identity from the state and events and promoting the idea that some pieces of state could be queries directly from historical events (although it has some drawbacks).
Eventuous started as being EventStoreDB-centric, as I believe it’s the best database for event-sourced systems (disclaimer: I work at Event Store). Still, I know that some people can’t use it for different reasons (mostly related to their employer’s constraints). With the community's help, I built a PostgreSQL implementation of the event store abstractions, so you can start using Postgres and migrate to EventStoreDB when the time comes. The code will be exactly the same!
I started building a spin-off of Eventuous, the Connector. It’s not something new or unknown, as you might compare it with Kafka Connect. The Connector is based on the Eventuous subscriptions module, so it has all the nice things like partitioned concurrent consumers and full coverage with traces. It goes beyond the Kafka connectors idea that just shovels messages from one place to another (and one of those must be Kafka). The Projector mode is quite unique as it allows you to do map-reduce operations on events and project multiple event types to a single object (document or table row). One of the goals was also to unblock users of EventStoreDB that have no gRPC client for their stack, so they can at least create read-model projections without caring about the mechanics too much. I had to prove to myself that it would work, so I built sample sidecars using TypeScript and PHP. I thought if I could build a sidecar for Connector in PHP, a decent PHP developer could do it too, and it would be 100 times better. The idea has proven to be exciting and useful. I got some feedback from the users, and more features for the Connector are in the works.
As usual, keeping the docs up to date is not an easy task. But there, I also got cheering feedback: “I read your docs and learned how to build an event-sourced system”. Truth be told, that was precisely my intention :) Learning by doing is always the best way.
So, what’s coming next? I have a few things going on in my mind that I either plan or already work on:
- Generic gRPC module for Connector
- Basic Kafka subscription, a follow-up of the basic producer for Kafka
- Kafka producer and subscription that uses the schema registry
- Google PubSub and Kafka support for Connector
One of the most exciting things I am looking forward to implementing is integration with Proto Actor. I had the privilege to work with Roger Johansson, the creator of Akka.NET and Proto Actor frameworks, and made some minor contributions to Proto Actor .NET. I am also excited about using the actor model together with Event Sourcing for quite a while and even delivered a talk about it back in 2019 (it wasn’t great, sorry). So, I really want to build something that would bring Eventuous and Proto Actor together.
I must admit that it’s not all I have in mind, but I don’t want to promise too much. Some exciting things I won’t disclose, so no one can blame me for not delivering those in time :)
Right now, Eventuous is sponsored by giving me paid time to build it by both of my employers: ABAX and Event Store. If you understand the effort needed to maintain an Open-Source project and want to contribute — participate by discussing issues, fixing bugs, building new features, etc. If you don’t have time for all that but still want to help — you can support the project financially. You can also buy a couple of hours of my time to discuss your projects where you use Eventuous, have your code reviewed, etc.
Finally, you might wonder why people need yet another “Event Sourcing Framework”? Didn’t Greg Young say, "you don’t need an Event Sourcing Framework; it’s easy”? Yes, he did. Maybe it’s dead easy for Greg after spending years building event-sourced systems, and I don’t know. I found myself in a position where I build almost the same bootstrap code for each project in which I am involved, and we are using Event Sourcing. I feel that all the experience I got from it, doing it over and over again, can be consolidated into a piece of software that many people can benefit from, so it cannot be a closed-source effort of individual companies.
That’s why Eventuous exists.