coyote

In the context of C#, most code does not actively share mutable state even if it's vastly concurrent and/or parallel via Tasks or explicit threading. In case the state is still shared, most common scenarios are usually addressed by applying concurrent data structures (ConcurrentDictionary/Stack/Queue) or using a barrier/semaphoreslim. In case where more complex mutable state must be shared in a non-thread-safe way, it is nowadays easily addressed by using Channel<T> where a single reader owns the instance of a particular class and handles concurrently submitted requests in a serialized way. Otherwise, I agree that correctly writing non-blocking code or code with granular locking strategy is extremely non-trivial, and the state space that must be handled for even most trivial cases is enormous and makes my head hurt. Some scenarios can be

in C# it's basically automatic https://github.com/microsoft/coyote/

Given F# compiler outputs legal IL that is expected to execute in a particular way, and CoreCLR doesn't fail on importing it, and then executing it, it has probably more to do with either Coyote or other tooling that interacts with this setup. That is, if the issue persists. There's one that mentions F# submitted in 2020, but nothing else since: https://github.com/microsoft/coyote/issues/39 Edit: Whoops, meant to reference this one: https://stackoverflow.com/questions/61694051/how-to-use-micr... I don't understand why there is less tolerance for having to make accommodations or take extra steps when working with F# than, let's say, when using Kotlin or Scala. Both follow a similar pattern where they can use pretty much every Java library by virtue of targeting JVM but can't use a huge amount of Java-only tooling that does meta-programming

I believe Java has exactly that, but I couldn't recall the project name. In the case of .NET, there is https://github.com/microsoft/coyote which works by rewriting IL to inject hooks that control concurrent execution state. It would have been much more expensive to have a custom interpreter specifically for this task (CoreCLR never interprets IL). This approach somewhat reminds me of precise release-mode debugging and tracing framework for C++ a friend of mine was talking about, which relies on either manually adding the hooks to source files or doing so automatically with a tool.

yes if your test are using a mock of the db ex: https://github.com/microsoft/coyote/blob/main/Samples/Accoun... you can simulate the races. The problem is your mock need to implement the same isolation level as your real DB and support transaction ... You could use SQLITE in memory DB to run your test but that would make your test a lot slower I assume.

I knew of this issue for some time (default DB isolation is less than SERIALIZABLE on most DB). But assuming you do not want to change the default isolation for your transaction or for the whole DB. How do you write unit-test that check your code will work correctly because it's using "select balance from accounts FOR UPDATE"? It seem to me the only way to really validate this is using tool like TLA+. Or something like https://github.com/microsoft/coyote

Always good to see more examples of this sort of project; making it straightforward to test how systems behave with unreliable networks [1] should make building resilient systems easier. I came across Microsoft's Coyote project [2] a while back, which seems similar to this, though for C#. Has anyone here tried that out? If so, what have your experiences with it been like? [1] Also known as any network ever. [2] https://github.com/microsoft/coyote

Microsoft has a library/tool called Coyote* that helps with testing distributed systems; you can write tests/specifications, Coyote will systematically explore nondeterminism in your system and check if your tests still pass. If there's a failure, it'll show the sequence of events that led to the failing test. I started a project to implement Raft with a KV-store on top, similar to the article, meaning to use Coyote to test it; I didn't get that far before losing interest, though. It's reassuring to read that it took Phil several months to write the code in the post, it's good to know that this is a decidedly nontrivial problem. * https://github.com/microsoft/coyote

This is similar to https://github.com/microsoft/coyote/