Marten was conceived and launched way back in 2016 as an attempt to quickly improve the performance and stability of a mission critical web application by utilizing Postgresql and its new JSON capabilities as a replacement for a 3rd party document database – and do that in a hurry before the next busy season. My former colleagues and I did succeed in that endeavor, but more importantly for the longer run, Marten was also launched as an open source project on GitHub and quickly attracted attention from other developers. The addition of an originally small feature set for event sourcing dramatically increased interest and participation in Marten.
Fast forward to today, and we have a vibrant community of engaged users and a core team of contributors that are constantly improving the tool and discussing ideas about how to make it even better. The giant V4 release last year brought an overhaul of almost all the library internals and plenty of new capabilities. V5 followed early in 2022 with more multi-tenancy options and better tooling for development lifecycles and database management based on early issues with V4.
At this point, I’d list the strong points of Marten that we’ve already achieved as:
- A very useful document database option that provides the powerful developer productivity you expect from NoSQL solutions while also supporting a strong consistency model that’s usually missing from NoSQL databases.
- A wide range of viable hosting options by virtue of being on top of Postgresql. No cloud vendor lock-in with Marten!
- Quite possibly the easiest way to build an application using Event Sourcing in .NET with both event storage and user defined view projections in the box
- A great local development story through the simple ability to run Postgresql in a Docker container and Marten’s focus on an “it just works” style database schema management subsystem
- The aforementioned core team and active user base makes Marten a viable OSS tool for teams wanting some reassurance that Marten is going to be well supported in the future
Great! But now it’s time to talk about the next steps we’re planning to take Marten to even greater heights in the forthcoming Marten V6 that’s being planned now. The overarching theme is to remove the most common hurdles for not choosing Marten. By and large, I think the biggest themes for Marten are:
- Scalability, so Marten can be used for much larger data sets. From user feedback, Marten is able to handle data sets of 10 million events today, but there’s opportunities to go far, far larger than that.
- Improvements to operational support. Database migrations when documents change, rebuilding projections without downtime, usage metrics, and better support for using multiple databases for multi-tenancy
- Marten is in good shape as a purely storage option for Event Sourcing, but users are very often asking for an array of subscription options to propagate events captured by Marten
- More powerful options for aggregating event data into more complex projected views
- Improving the Linq and other querying support is a seemingly never-ending battle
- The lack of professional support for Marten. Obviously a lot of shops and teams are perfectly comfortable with using FOSS tools knowing that they may have to roll up their sleeves and pitch in with support, but other shops are not comfortable with this at all and will not allow FOSS usage for critical functions. More on this later.
First though, Marten is getting a new “critter” friend in the larger JasperFx project family:
Wolverine is a new/old OSS command bus and messaging tool for .NET. It’s what was formerly being developed as Jasper, but the Marten team decided to rebrand the tool as a natural partner with Marten (both animals plus Weasel are members of the Mustelidae family). While both Marten and Wolverine are happily usable without each other, we think that the integration of these tools gives us the opportunity to build a full fledged platform for building applications in .NET using a CQRS architecture with Event Sourcing. Moreover, we think there’s a significant gap in .NET for this kind of tooling and we hope to fill that.
So, onto future plans…
There’s a couple immediate ways to improve the scalability of Marten we’re planning to build in Marten V6. The first idea is to utilize Postgresql table sharding in a couple different ways.
First, we can enable sharding on document tables based on user defined criteria through Marten configuration. The big challenge there is to provide a good migration strategy for doing this as it requires at least a 3 step process of copying the existing table data off to the side before creating the new tables.
The next idea is to shard the event storage tables as well, with the immediate idea being to shard off of archived status to effectively create a “hot” storage of recent events and a “cold” storage of older events that are much less frequently accessed. This would allow Marten users to keep the active “hot” event storage to a much smaller size and therefore greatly improve potential performance even as the database continues to grow.
We’re not done “sharding” yet, but this time we need to shift to the asynchronous projection support in Marten. The core team has some ideas to improve the throughput of the asynchronous projection code as it is, but today it’s limited to only running on one single application node with “hot/cold” rollover support. With some help from Wolverine, we’re hoping to build a “sharded” asynchronous projection that can shard the processing of single projections and distribute the projection work across potentially many nodes as shown in the following diagram:
The asynchronous projection sharding is going to be a big deal for Marten all by itself, but there’s some other potentially big wins for Marten V6 with better tooling for projection rebuilds and asynchronous projections in general:
- Some kind of user interface to monitor and manage the asynchronous projections
- Faster projection rebuilds
- Zero downtime projection rebuilds
Marten + Wolverine == “Critter Stack”
Again, both Marten and Wolverine will be completely usable independently, but we think there’s some potential synergy through the combination. One of the potential advantages of combining the tools is to use Wolverine’s messaging to give Marten a full fledged subscription model for Marten events. All told we’re planning three different mechanisms for propagating Marten events to the rest of your system:
- Through Wolverine’s transactional outbox right at the point of event capture when you care more about immediate delivery than strict ordering (this is already working)
- Through Martens asynchronous daemon when you do need strict ordering
- If this works out, through CDC event streaming straight from the database to Kafka/Pulsar/Kinesis
That brings me to the last topic I wanted to talk about in this post. Marten and Wolverine in their current form will remain FOSS under the MIT license, but it’s past time to make a real business out of these tools.
I don’t know how this is exactly going to work out yet, but the core Marten team is actively planning on building a business around Marten and now Wolverine. I’m not sure if this will be the front company, but I personally have formed a new company named “Jasper Fx Software” for my own activity – but that’s going to be limited to just being side work for at least awhile.
The general idea – so far – is to offer:
- Support contracts for Marten
- Consulting services, especially for help modeling and maximizing the usage of the event sourcing support
- Training workshops
- Add on products that add the advanced features I described earlier in this post
Maybe success leads us to offering a SaaS model for Marten, but I see that as a long way down the road.
What think you gentle reader? Does any of this sound attractive? Should we be focusing on something else altogether?
2 thoughts on “Marten and Friend’s (Hopefully) Big Future!”
Hello, at work we use Marten and we are really happy to have chosen Marten as our ORM.
Currently we use MediatR for CQRS and utilize the build in pipe line functionality to dispatch (in process) domain events and afterward commit the changes to Db and as last step publish integration events (that are saved in a table within the same Db transaction).
Will Wolverine be able to specify certain type of “messages” should be send in process while others should be send to a external service bus?
By moving in the direction of a consulting company would the today existing Gitter channel close at some point?
Big thank you and the “critter” team for the great libraries and blog post!
So, yes the Gitter room will stay open, but we’ve got to figure that out a bit.
“Will Wolverine be able to specify certain type of “messages” should be send in process while others should be send to a external service bus?”
Yes, and it can already do this today.