Hopac VS express-c

https://github.com/Hopac/Hopac is such an impressive piece of software. Too bad it never really took off like it deserved but with more popular competition like rx or just tasks/async (which is enough for most stuff) pretty unavoidable.

Found this article, it didn't even occur to me to look for a channel library in JS. This is definitely the direction to go in. Incidentally, Hopac is the most underrated of all F# libraries, just sayin'.

3) This third part is the hardest, and that is to get proficient at concurrency itself. For this I had to study various libraries like Rx, but what I settled on after a lot of experimentation was to first compile the various passes to streams of lazy promises. For languages in particular, they have a top down structure and what is needed is to employ a lot of diffing in order to reuse old results. The difficult part is to organize all of this. I can't praise a library like Hopac enough, but even with it, it still took me months to get a grasp on the way the editor support segments should be designed. At the time of writing, I am a day away of finalizing what will be the true design of the language server. It is not that the end result is complex, this latest redesign of the last 1.5 weeks is in fact significantly simpler than what I had before, but concurrency requires different design principles than sequential programming and getting used to the new domain takes an active effort.

GCD/libdispatch is a fantastic approach to concurrency and you can build and install support for non-Apple operating systems:

https://github.com/apple/swift-corelibs-libdispatch

Here’s a simple echo server:

https://github.com/williamcotton/c_playground/blob/master/sr...

Here’s a simple multithreaded database pool:

https://github.com/williamcotton/express-c/blob/master/src/d...

Apache does this! And I do this in my own C web framework:

https://github.com/williamcotton/express-c/blob/master/deps/...

Unfortunately not all of the sanitizers are working in clang for Apple Silicon machines. For my own CI pipeline I run both Darwin and Linux builds, leaks and valgrind respectively, along with the kitchen sink of compiler sanitizers:

Here’s the GitHub actions for those platforms and a link to the Makefile:

GitHub Action:

https://github.com/williamcotton/express-c/blob/master/.gith...

Makefile:

https://github.com/williamcotton/express-c/blob/f2e1dde2f5a7...

Lol, yeah, the libdispatch runtime is probably about as big as the Go runtime!

I think this has a slight advantage in that it uses a memory arena for a per-request bump allocator so it should keep overall memory usage lower.

The slowest part of all this has to do with Block_copy and the places where I’m very much treating blocks/closures in an OOP type manner.

This could be fixed by writing a different function that did basically the same thing as Block_copy but for all the “methods” on an “object” in a single pass. But who has time for that? :D

Here’s more about those performance issues and some text code that show how slow the approach is:

https://github.com/williamcotton/express-c/tree/master/resea...

I’ve used an approach to copy only the shared libs from the build container to the production container. This not only gets rid of most of this “dark matter” but results in much smaller containers!

https://github.com/williamcotton/express-c/blob/master/demo/...

I use arenas for HTTP request handlers. The JSON built or parsed is only going to be around for the lifetime of the request. It's much simpler and faster to use an arena than to do reference counting wrapped around malloc/free.

Here's an example where in a commit I swapped in an arena:

https://github.com/williamcotton/express-c/commit/4ae53f38e3...