sml VS Boost.Beast

Anyway the need is not complicated, I need both entry and exit functions from every state, optionally allowing these functions to be coroutines (that's special sauce but for later), and an explicit state transition table which also have a way to say that a state can be accessed at any point. Also allow states to be state machines, optional FSM hierarchies. If you ignore the coroutine stuff it's pretty standard features these days, except that - Boost.MSM is quite archaic now (it was so novel when it was first released...) although it allows most of the features I talked about, I just think it will complicate my code unneecessarilly; - Boost-Ext.SML (not Boost) is almost perfect except it doesnt have entry/exit functions on states for some reason. Also last time we (as in in livestream) tried it in prototypes it didnt compile on msvc XD - Boost-Ext.SML2 is even better but still doesnt have entry/exit functions although it's in the plans.

Hello all. Being a huge fan of state machine and coroutines, I have been browsing around for examples of what other people do combine these two. I have been using boost-ext/sml for quite many projects and are quite happy about that. But when transitioning to code that relies on coroutines, I would like to write entry/exit/actions/guard methods that uses coroutines and where I can co_await on awaitables from Asio and more recently "Boost Async".

boost-ext/sml: quite modern way of doing state machines using a DSL

I recently was troubleshooting a crash that backtraced through the boost::sml library [0]. The crash didn't actually have anything to do with the library, but it was used as the core event loop.

The backtrace -- as in, just the output from running `bt` in GDB -- was over a thousand wrapped lines long. There were ~5 stack frames that took up 200 lines of console each to print just the function name. That product's debug builds recently hit the 2GB line, which is enough that old versions of binutils complain.

I don't know what the solution is. There's some really neat stuff you can do with template metaprogramming, and in stripped release builds it compiles down extremely tiny. Plus the code is very clean to read. But it does feel like there isn't any kind of central vision for the C++ debugging experience, and bad interactions between highly-complex modern C++ typing, the compiler, and the debugger are probably only going to get worse unless somebody (the ISO committee? Vendors?) thinks really hard about debugging support.

[0]: https://github.com/boost-ext/sml

I'm a big fan of MSM but what you're experiencing is pretty normal for template-heavy libraries built on C++03 machinery (emulation of variadic templates is the usual culprit). It's probably not the answer you're hoping for, but the real solution is to switch to a library with more modern foundations. (I've been happily using [Boost::ext].SML for a few years but I'm reluctant to strongly recommend anything in particular since I haven't re-explored the problem space since I found it.)

The Boost one that you mention, seems to be one that it's kinda old. A "successor" of sorts is Boost SML. I've not used it yet, but certainly the first impressions are very good.

Or Boost.Sml

At our company, we rely a lot on https://github.com/boost-ext/sml

I'm a big fan of boost::sml for representing state machines.

https://github.com/boost-ext/sml (State Machine DSL and backend for perfomance)

There is at least one notable exception to this rule: https://github.com/boostorg/beast/issues/1445

I am using this example : https://github.com/boostorg/beast/blob/develop/example/websocket/client/async-ssl/websocket_client_async_ssl.cpp My application is listening to tick data streams of crypto exchanges over the websockets and processing and sending orders to the exchange.

We used beast to implement a market data server(and I think we also did a small client, to test it) which was sending protobuf messages, and it worked great(we also used boost adio, which made it very scalable). When we tested the server, we were generating around 100k messages per second(when there was the biggest activity on the market), I think I've posted here some stats: https://github.com/boostorg/beast/issues/2313.

Boost Beast?

And Chris wrote this example, which is faster than any of my other examples: https://github.com/boostorg/beast/tree/21cd552399aa8167ed53c21a74f3711c2c316d2f/example/http/server/fast

cmake -h. -Bbuild && cmake --build build

to work about 90% of the time. Far more luck than I've had with autotools.

> Its code is horrifying too, for example:

1) I'm sure I could find some horriffic code in meson too if I went digging. 2) The alternative to this is you having to write something equivalent in your own code, meaning that in my code I don't need to do stuff like [0] in my code to detect features; my build system handles it for me. 3) CMake supports more platforms and targets than I've ever seen in my life, and likely supports more compilers than are necessary. that's a blessing and a curse, but it means that if I write simple program to run on some crufty microcontroller with a bastardised gcc toolchain from the 90s, it's fairly likely that cmake supports it out of the box. Code like that is the price to pay for that level of support.

[0] https://github.com/boostorg/beast/blob/b7344b0d501f23f763a76...

If you need an embedded C++ HTTP server then there are plenty of libraries/frameworks (in random order): Crow, RESTinio, Boost.Beast, cpp-httplib, http_backend, Pistache, RestBed, served, proxygen, Simple-Web-Server, drogon, oat++.