lucene-grep VS coyote

- Graal native images are real. These boast a far lower startup overhead and much lower steady state memory usage for simpler applications.

Probably my counterexample of choice is this: https://github.com/dainiusjocas/lucene-grep - it uses Lucene, probably the best search library (core of Elasticsearch, Solr, most websites), which is notoriously not simple code to implement grep-like functionality. In simple cases, they demonstrate a 30ms whole process runtime with no more than 32MB of RAM used (which looks suspiciously like a default).

The JVM is fast becoming a bit like Postgres... one of those 'second best at everything' pieces of tech.

Here goes: https://github.com/dainiusjocas/lucene-grep/issues/84

I realize some relatively obscure Finnish stemmer and Lucene with GraalVM aren't exactly a common use case. I did some testing and provided my use case. I certainly have much English language content to search with using lucene-grep. So, thank you for making it!

For anyone writing services in C# there’s a project from MSR called Coyote that does similar deterministic simulation testing by systematically testing interleavings of async code.

https://microsoft.github.io/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 the case when 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 a mailbox/Channel where a single reader owns an instance of a particular class and handles concurrently submitted requests in a serialized way.

Otherwise, I agree that correctly writing non-blocking code 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 addressed by https://github.com/microsoft/coyote which simplifies the task, but it is still challenging.

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

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 can't use a huge amount of Java-only tooling and yet it's not seen as such a huge ordeal.

ex: https://github.com/microsoft/coyote/blob/main/Samples/Accoun...

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

Something like coyote by MS?

If you're looking for similar concurrency testing in the dotnet world, checkout Coyote:

https://microsoft.github.io/coyote/

https://innovation.microsoft.com/en-us/exploring-project-coy...

MS provides a framework for testing for concurrency issues: https://microsoft.github.io/coyote/.

I suggest you try Microsoft Coyote