tdrd

I'm surprised Reviewable[0] hasn't come up in this discussion. It does a great job of allowing stacked code reviews and even handles rebases nicely; the reviewer sees the diff between commit #1 and commit #1' (prime = after rebase).

CockroachDB[1] has been using it since very early in the project.

[0] https://reviewable.io/

[1] https://github.com/cockroachdb/cockroach

Maybe so folks could build web UIs to interact with a local instance? Can't do raw TCP/UDP from a web browser.

OP was quoting.

The examples in this article are all straw men; where's the compelling specific case where 5 whys lead to some demonstrable mistake?

Nothing to see here.

Author of [0] here.

Sadly, those benchmarks (at the bottom of the thread) were done with a GCC that already included all the GCC 8.1 bells and whistles - results were unchanged under 8.1.

So it's still _really_ slow.

Lots of comments here about lack of JSON support in gRPC - while that's true, it's relatively easily to bolt on using grpc-gateway (https://github.com/grpc-ecosystem/grpc-gateway).

Here's how we did it in CockroachDB: https://github.com/cockroachdb/cockroach/blob/24ed8df04719a1...

The supporting code (protoutil) is https://godoc.org/github.com/cockroachdb/cockroach/pkg/util/... and https://godoc.org/github.com/cockroachdb/cockroach/pkg/util/....

The downside to this solution is that the concrete option types are exported. I believe it's possible to return unexported types from exported functions, which would solve this, but that golint complains about that pattern.

Have you suggested this to the etcd maintainers?

Really solid. I fed it a recent nasty line from our Makefile: https://github.com/cockroachdb/cockroach/blob/4aeef50/build/...

Looks like it doesn't deal with subshells, but otherwise it did reasonably well.

http://explainshell.com/explain?cmd=find+.+-name+*.pb.cc+%7C...

[Cockroach Labs employee]

In addition to being extremely precise, TrueTime is explicit about error in its measurements.

In other words, a call to TrueTime returns a lower and upper bound for the current time, which is important for systems like Spanner or CockroachDB when operations must be linearized.

In effect, Spanner sleeps on each operation for a duration of [latest_upper_bound - current_lower_bound] to ensure that operations are strictly ordered.

Your suggestion might improve typical clock synchronization, but still leaves defining the critical offset threshold to the operator, and importantly leaves little choice for software like CockroachDB other than to crash when it detects that the invariant is violated.

Doesn't seem possible to use this yet. No client libraries and no samples: https://cloud.google.com/spanner/docs/tutorials

Have they documented the wire protocol? I couldn't find it.

It's not even clear that this is about running. They compared runners to sedentary individuals; this sounds like another "exercise is good" conclusion to me.

Cockroach Labs employee here - the implementation only uses a single context key, so traversing the context linked list is only necessary when the context in hand is a derivative of the annotated context (e.g. obtained via WithTimeout or WithCancel), which is relatively uncommon in practice.

https://github.com/cockroachdb/cockroach/blob/6b0698f/pkg/ut...

This presumes that MS tracks the fact that you've opted out of tracking, which is not obviously the case.

Here's the landing from the webcast video on youtube https://youtu.be/L0bMeDj76ig?t=2300

(employee here)

It seems to me that your use-case does not require locking specifically - you just want to make sure no concurrent transactions can clobber your "update A".

As mrtracy explained, such overlapping transactions are linearizable in CockroachDB, so this invariant is preserved without the need for explicit locking.

This appears to hammer GitHub's API pretty aggressively. I attempted to import https://github.com/cockroachdb/cockroach and a few hours later my API limit is exceeded.

Seems bad.

One of my old co-workers said it best: "Dear @SpaceX and @NASA security teams: please don't sign your firmware, in case a space gardener ever needs to bust out a hex editor."

[0] https://twitter.com/nathanmccauley/status/650450050724708356

...is it documented anywhere? where?

Don't see the problem here. He did not intimidate, falsify evidence, or otherwise violate due process.

His job is (was) to uphold the law, not his boss' moral code.

Obviously there's no avoiding this, but the author writes in the context of high-level code where OS-provided locking mechanisms are available. Why are we discussing this in a low-level (or embedded, where every ounce of performance matters) context?

This is a good academic post, but why are we still writing mutable-shared-state concurrent code?

Either of message-passing concurrency and data immutability would trivialize the problems discussed here.

The bumper case is also now showing "Coming soon". https://play.google.com/store/devices/details/Nexus_4_Bumper....

I wonder if they took the merchandise down while they work on the load issues.

This paper is from 2008. Where is this being used?

Why does stripe need to out-compete this? They still get their cut.

Chrome on iOS uses safari's layout engine (because Apple doesn't allow dynamic code generation) but the network stack is Chrome's.

I can feel myself getting dumber reading this discussion. Christoph Husse is a donkey.