
Porcupine: A fast linearizability checker written in Go - cube2222
https://github.com/anishathalye/porcupine/blob/master/README.md
======
dis-sys
I used Porcupine in my project, it is in general much faster, but for some
limited cases it is slower, sometimes it is much slower.

btw, the author anishathalye is the guy who tricked google AI into thinking
his 3D-printed turtle is a rifle.

------
wolf550e
Is that x1000 performance improvement over Jepsen algorithmic or Go over
Clojure?

~~~
cube2222
It seems like he/she's attributing the speedup to the paper cited in the
readme[1].

Go shouldn't be much faster than clojure, the jvm is fast.

[1]:[https://arxiv.org/pdf/1504.00204.pdf](https://arxiv.org/pdf/1504.00204.pdf)

~~~
fulafel
Clojure is actually a bunch slower than Java with idiomatic code, i the Python
ballpark. But you can speed it up and make it mostly emit Java-equivalent JVM
bytecode with a bunch of optional annotations.

~~~
enitihas
Yes, and you can set a flag to varn you if the annotations are not set
somewhere. Using proper hints clojure is in the same magnitude as java and
much faster than python

------
agnivade
Can someone ELI5 what is a linearizability checker ?

~~~
cube2222
"If we assume that there is a single global state that each process talks to;
if we assume that operations on that state take place atomically, without
stepping on each other’s toes; then we can rule out a great many histories
indeed. We know that each operation appears to take effect atomically at some
point between its invocation and completion.

We call this consistency model linearizability; because although operations
are concurrent, and take time, there is some place–or the appearance of a
place–where every operation happens in a nice linear order."

\--- cited from [https://aphyr.com/posts/313-strong-consistency-
models](https://aphyr.com/posts/313-strong-consistency-models)

