Sai Charan

From Bartosz Milewski’s What Does Haskell Have to Do with C++?: Haskell style list comprehensions of the form

one x = 1
count lst = sum [one x | x <- lst]

can be written in modern C++ like so:

template<class T> struct
one {
    static const int value = 1;
};

template<class... lst> struct
count {
    static const int value = sum<one<lst>::value...>::value;
};

The author calls out the comparison between one<lst>::value... and [one x | x <- lst]. I’ve used packs like this before, but looking at this juxtaposition was a revelation.

The ACM Queue article titled Standing on Distributed Shoulders of Giants was a fascinating read. Some excerpts:

“Two-phase commit is the anti-availability protocol.”

“Computing is like Hubble’s universe…Everything is getting farther away from everything else.”

“Shared memory works great… as long as you don’t share memory.”

This one took a bit of squinting at to make sense. Here, Pat Helland is referring to the fact that there are retries and given we store copies for redundancy, we can only know for certain where the request was processed **OR** that it was successfully completed. In a sense, once you know it was completed, you can back trace where it was done, but that is hindsight.

“In a distributed system, you can know where the work is done or you can know when the work is done but you can’t know both.”

This one’s on eventual consistency:

“While not yet observed, a put does not really exist… it’s likely to exist but you can’t be sure. Only after it is seen by a get will the put really exist.”

The references at the end of the article are also good refreshers on Distributed Systems/Computing.