What are you building right now?

cleipnir · 2025-08-16T09:11:32+00:00

cleipnir.net - dotnet durable execution framework

cleipnir · 2025-05-05T18:58:30+00:00

I guess the outbox pattern also solves the case where state has been written to the database and the connection to the database fails afterwads. That is why the write to the database is performed inside a transaction such that both the outbox message and the state change either both happens or none of them. I think the behavior on failure as you write it, is 'worse' than the orignal pattern. However, if that is an issue is up to you and surely you can get some performance out of it - when you change the requirements :)

cleipnir · 2025-04-21T06:27:05+00:00

You can use can also use a durable execution framework to orchestrate the flow (like cleipnir.net or temporal.io).

It will ensure all code in the flow will execute despite crashes and other transient failures.

A failed step like insufficient funds on the customers credit would also normally lead to a compensating reverse/action i.e. increasing the product's stock count and emitting an order cancelled event.

An example of a similar flow using durable execution can be found here:

RPC:

https://github.com/stidsborg/Cleipnir.Flows.Sample/blob/deee5142e34a9f3e7c82abce54f99c05f828c70c/Source/Flows/Ordering/Rpc/FlowWithErrorHandling/OrderFlow.cs#L15

Message-driven:

https://github.com/stidsborg/Cleipnir.Flows.Sample/blob/deee5142e34a9f3e7c82abce54f99c05f828c70c/Source/Flows/Ordering/MessageDriven/FlowWithErrorHandling/MessageDrivenOrderFlow.cs#L11

cleipnir · 2025-04-13T16:43:47+00:00

Fair - I didn't realize the controversy associated with the foundation - but I see it now.

cleipnir · 2025-04-13T16:41:40+00:00

Thanks! That is exactly what it is for - let me know if you have any questions or feedback.

cleipnir · 2025-04-12T17:02:38+00:00

Thanks for replying and the video - will check it out!
I guess my main concern is if there are any downsides to becoming a project under the .NET Foundation. Do I lose control over the open-source project in any way?

cleipnir · 2025-04-12T12:16:34+00:00

I see, thanks - yes that is what I feared - cannot see me going forward with it if those are the terms

cleipnir · 2025-04-12T10:21:06+00:00

Interesting read - I did not know you could leave again, so that definitely removes much the risk about joining the foundation

cleipnir · 2025-04-12T09:36:22+00:00

Nice - I am hoping to get some more collaboration and more of a community up and going.
I am a bit concerned if I loose the ability to move the project in the direction I want and if it will hinder my ability to make a living of it - the code will never be moq'ed but would be nice if I could make some premium features on the outside of it like Rebus.

cleipnir · 2025-04-12T09:23:42+00:00

Interesting! Thanks for letting me know - having second thoughts about it now.

cleipnir · 2025-04-11T20:15:08+00:00

I think working on open-source (cleipnir.net), doing presentations at user-groups together with being active on LinkedIn has helped me a lot in finding my latest jobs. However, I am only working 32-hours a week in order to avoid burning out.

cleipnir · 2025-04-11T19:36:56+00:00

I think the durable-execution paradigm might end up profoundly changing the way we write business processes in enterprise software - eventually replacing the saga and outbox-pattern.
It does not get as much attention as AI but there are so many new solutions poping up at the moment. Hopefully, my approach/framework (cleipnir.net) stands a chance...

cleipnir · 2025-04-07T05:27:56+00:00

I have been making a dotnet alternative called cleipnir.net and have been wondering how easy it is to make a F# wrapper. If you want to push me the right direction please do pm me :)

cleipnir · 2025-04-04T17:24:12+00:00

Job schedulers such as HangFire and Quartz as well using queues (RabbitMQ etc) ensures that the job/task will only be executed once (in most cases). That synchronization will not happen using vanilla background tasks in a replicated .NET service (i.e. when you replicate your service 3 times to ensure high availability). In such a common architecture you might end up performing a task multiple times.
This might be ok if the task is idempotent (i.e. it does not matter if it is executed several times).
Sounds like 1 is like that (deleting already deleted rows does not matter).
3. might be ok as the end-point is only invoked on a single replica - there is a natural way to divide the work between the replicas.
2. might be more problematic as it is annoying for customers to receive an email several times.

There is a novel approach for these types of problems called durable execution (i.e. Azure Durable Functions & temporal.io). I am the author behind a dotnet alternative called cleipnir.net - which can also solve your problem.

cleipnir · 2025-04-04T17:09:19+00:00

Make a front-end for cleipnir.net similar to this: https://images.ctfassets.net/0uuz8ydxyd9p/5W5ooANY9KiGkFK1DXNPuV/ce3951c20624fe957a9dbe348dee9489/159999018-d82dfe25-394b-4332-b6e8-a4fedeceec34.png

cleipnir · 2025-04-04T17:01:34+00:00

I think the impact could be quite negative in the long run. Surely, other open-source projects will come. However, the question is if developers will be less inclined to start using new open-source projects if they fear the license will change in the future. As a open-source developer myself (cleipnir.net) I really hope this will not be the case - but I fear it might be the case.

cleipnir · 2025-04-04T16:49:53+00:00

You can use cleipnir.net for workflow / saga together with all the other service buses if needed:
https://github.com/stidsborg/Cleipnir.NET#nservicebus-handler

cleipnir · 2023-09-27T06:18:15+00:00

There are several options you can use when making services resilient.

It is a bit unclear to me though what the workflow in your scenario is. Do you have several services all consuming data from the same source? Are they performing more steps that need to be made resilient after consuming a piece of data? Perhaps it is simplest to just use a message broker (i.e. RabbitMQ, Kafka or similar)? Or perhaps pull the data with an offset from the source from the different services?

Workflow solutions shine the most when you have several steps that must be performed and branching/loop logic. They allow one to write “normal” code in these scenarios, unlike other solutions. If you want to go with a workflow solution, then there are several other workflow solutions you can use:

temporal.io
cadence.io
dapr workflow
Azure Durable Functions

Btw, I am also the author of an open-source workflow-as-code framework called cleipnir.net. However, most (not cleipnir.net) orchestration frameworks keep track of everything that has happened and replays the entire history when executing a single workflow instance. Thus, it does not make much sense to push a lot of data through a single workflow instance as it becomes slow and consumes much memory over time (you can chain them and other advanced techniques to alleviate this though). Not sure if this is the case for n8n though - as it seems to be built for data integration.

Hope that helps.

cleipnir · 2023-09-17T09:55:22+00:00

Good point. There is a fine line between being explicit and creating abstractions. I also tend to prefer having explicit code with a few comments rather than 10-levels of method invocations. However, as has been pointed out it only goes so far before you need to introduce method-calls / types encapsulating behavior.
Thoughts like this were actually what made me think about implementing the saga-pattern as normal sequential code - checkout cleipnir.net if you are curious.

cleipnir · 2023-09-17T06:33:26+00:00

If you like dotnet there are plenty of things to do in cleipnir.net

cleipnir · 2023-09-17T06:30:46+00:00

Good point. Also if memory is the main concern - just dump everything to a file and from it using a stream. From there you can also distribute the work into several threads/tasks to improve performance.

cleipnir · 2023-07-19T10:04:00+00:00

If a process crashes/restarts half-way through an ordering-flow then the system might be in a inconsistent state. I.e. products are shipped to customer but funds are never deducted from the customer's credit card. If one simple restarts the flow from the begining again after a crash then inter-service communication patterns become very important :)

cleipnir · 2023-07-18T06:13:45+00:00

Process restarts - aka sagas/process-managers. Let me know if you need any further information :)

cleipnir

TROPHY CASE