Stateless vs. Appccelerate.StateMachine
I’ve been investigating workflow engines lately (specifically, state machine libraries) and it’s come down to Stateless vs. Appcelerate.StateMachine.
First, a digression on why I’m avoiding Windows Workflow Foundation (WF). It’s true that there’s tons of documentation, support from Microsoft, perhaps lots of experienced developers, but I count myself as one among many who feel burned by our experience with WF. I’ve used the first release of WF on FirstPoint and mostly ended up regretting it for the poor performance and complexity (making it hard for new developers to pick it up). I’ve also used the first release on various other SharePoint projects since then on top of Nintex and, again, it’s been dogged by hard to trace bugs, poor performance, and stuff that’s generally cumbersome (like deployment, for instance).
Microsoft seems to have addressed a lot of these issues by totally rewriting WF in .NET 4.0, but this in and of itself raises a serious question: how stable is the framework? Sure, Microsoft provided a migration path from legacy WFs to new WFs, but it’s still a headache. Aside from that, even just looking at the APIs, it’s clear that it’s extremely heavy and does nothing to alleviate the poor practices which are possible with WF.
Thus enters my search for alternatives including Amazon Simple Workflow. In the end, I’ve narrowed it down to Stateless and Appccelerate.StateMachine.
To test the intuitiveness, ease of use, and performance, I wrote a simple example with both of them. I modeled the phone example from the Stateless documentation and ran it in a loop of 1,000,000.
The loop looks like so:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
internal class Program { private static void Main(string[] args) { var stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < 1000000; i++) { var phone = new Phone(); phone.CallDialed(); phone.CallConnected(); phone.PlacedOnHold(); phone.TakenOffHold(); phone.HungUp(); } stopwatch.Stop(); Console.Out.WriteLine(stopwatch.ElapsedMilliseconds); } } |
The implementation of the phone in Stateless looks like so (common parts omitted for brevity):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
namespace StatelessTest { public class Phone { private readonly StateMachine<State, Trigger> _phone = new StateMachine<State, Trigger>(State.OffHook); private readonly Stopwatch _stopwatch = new Stopwatch(); public Phone() { _phone.Configure(State.OffHook) .Permit(Trigger.CallDialed, State.Ringing); _phone.Configure(State.Ringing) .Permit(Trigger.HungUp, State.OffHook) .Permit(Trigger.CallConnected, State.Connected); _phone.Configure(State.Connected) .OnEntry(StartCallTimer) .OnExit(StopCallTimer) .Permit(Trigger.LeftMessage, State.OffHook) .Permit(Trigger.HungUp, State.OffHook) .Permit(Trigger.PlacedOnHold, State.OnHold); _phone.Configure(State.OnHold) .SubstateOf(State.Connected) .Permit(Trigger.TakenOffHold, State.Connected) .Permit(Trigger.HungUp, State.OffHook) .Permit(Trigger.PhoneHurledAgainstWall, State.PhoneDestroyed); } private void StartCallTimer() { _stopwatch.Start(); } private void StopCallTimer() { _stopwatch.Stop(); } public void CallDialed() { _phone.Fire(Trigger.CallDialed); //Console.Out.WriteLine("Dialed"); } public void CallConnected() { _phone.Fire(Trigger.CallConnected); //Console.Out.WriteLine("Connected"); } public void PlacedOnHold() { _phone.Fire(Trigger.PlacedOnHold); //Console.Out.WriteLine("On Hold"); } public void TakenOffHold() { _phone.Fire(Trigger.TakenOffHold); //Console.Out.WriteLine("Off Hold"); } public void HungUp() { _phone.Fire(Trigger.HungUp); //Console.Out.WriteLine("Hung Up"); } } // Define enums here } |
The implementation of the phone in Appccelerate.StateMachine looks like so:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
namespace StateMachineTest { public class Phone { private readonly PassiveStateMachine<State, Trigger> _phone = new PassiveStateMachine<State, Trigger>(); private readonly Stopwatch _stopwatch = new Stopwatch(); public Phone() { _phone.In(State.OffHook) .On(Trigger.CallDialed).Goto(State.Ringing); _phone.In(State.Ringing) .On(Trigger.HungUp).Goto(State.OffHook) .On(Trigger.CallConnected).Goto(State.Connected); _phone.In(State.Connected) .ExecuteOnEntry(StartCallTimer) .ExecuteOnExit(StopCallTimer) .On(Trigger.LeftMessage).Goto(State.OffHook) .On(Trigger.HungUp).Goto(State.OffHook) .On(Trigger.PlacedOnHold).Goto(State.OnHold); _phone.DefineHierarchyOn(State.Connected) .WithHistoryType(HistoryType.None) .WithInitialSubState(State.OnHold); _phone.In(State.OnHold) .On(Trigger.TakenOffHold).Goto(State.Connected) .On(Trigger.HungUp).Goto(State.OffHook) .On(Trigger.PhoneHurledAgainstWall).Goto(State.PhoneDestroyed); } private void StartCallTimer() { _stopwatch.Start(); } private void StopCallTimer() { _stopwatch.Stop(); } public void CallDialed() { _phone.Fire(Trigger.CallDialed); //Console.Out.WriteLine("Dialed"); } public void CallConnected() { _phone.Fire(Trigger.CallConnected); //Console.Out.WriteLine("Connected"); } public void PlacedOnHold() { _phone.Fire(Trigger.PlacedOnHold); //Console.Out.WriteLine("On Hold"); } public void TakenOffHold() { _phone.Fire(Trigger.TakenOffHold); //Console.Out.WriteLine("Off Hold"); } public void HungUp() { _phone.Fire(Trigger.HungUp); //Console.Out.WriteLine("Hung Up"); } } // Define enums here } |
And here are the results:
Here are my observations:
- Stateless is about 4x faster than Appccelerate.StateMachine
- Stateless syntax is a little bit more intuitive for creating hierarchies
- Appccelerate.StateMachine documentation is much more thorough and much more complete than Stateless
- But Stateless has more downloads (thus more users) and more presence on StackOverflow (should you need it)
- Appccelerate.StateMachine has some cool features around logging and extensibility, but quite honestly, I don’t think they are needed given that if you use a composite pattern around your state machine, you can really manage that yourself much more concisely.
- The external persistence infrastructure of Stateless is simple, but not very intuitive or well documented
- The Appccelerate.StateMachine Nuget package did not work with the package manager console and Visual Studio 2012, requiring me to manually download and compile the source (which I don’t mind, but raises some doubt)
All said and done, I think we will use Stateless as it is a very barebones and highly performant state machine, which is perfect for our needs. Look for more Stateless posts in the future!
Attached is the sample code: StateMachineTest
