David Mazières, a Stanford computer science professor, writes about C++20 features, systems research papers and security topics.
HN links it for his C++20 coroutines tutorial, which commenters find useful despite its code overhead, and his paper on spam, "Get Me Off Your Fucking Mailing List".
Taking away the money part you'll probably want to replace "distributed chained ledger" with "distributed database" or "state-machine replication". There's actually a nice academic literature on this topic of having distributed databases that have strong notions of "commit". This is never the case with stuff that gets called "blockchain". I've yet to encounter something that isn't a variation on "rate-limit the ingest so we have time to replicate operations world-wide" or "create internal monkey-money incentives for agents not to diverge from corretness", both of which are trivial hacks that don't advance anything from a scientific point of view. Not my field tho, so here's the few refs i know.
https://en.wikipedia.org/wiki/Paxos_(computer_science) An old algorithm used for sharding big-data databases.
https://en.wikipedia.org/wiki/Raft_(algorithm) A simplified version of paxos.
http://www.scs.stanford.edu/~dm/home/papers/losa:stellar-instantiation.pdf The new paper about SCP which allows replication with subjective notions of trust (no central participant-stake list like paxos/raft).
ps: actually i remove "chained" from the idea. If you want to keep the whole authenticated linked-list thing and do it right you'll end up somewhere near https://irmin.org/ (a generalization of git), which is very useful, but doesn't tackle the "strong decentralized commit". You'll probably want to either centrally manage the "lastest-hash(s)" (like git is usually done), or pair it with a…
At the time, there was an arms race within the systems community to see who could flip a bigger bird to the organizers of the SCI spamference. David Mazieres and Eddie Kohler started it off when they submitted "Get Me Off Your Fucking Mailing List" [1] for publication. We wanted to one-up them and figured we could do so by submitting a random paper that might be accepted into the conference, allowing us to give an in-person talk. The plan worked up to a point, but when we asked the internet for $3k to send us to Orlando, the press and then the organizers of SCI caught wind and revoked the random paper they had previously accepted.
Everything since has been gravy. We're pumped that SCIgen is still a useful weapon against charlatans the world over (this now includes you, IEEE and Springer).
[1] http://www.scs.stanford.edu/~dm/home/papers/remove.pdf
Yeah there aren't many good resources on it unfortunately. One thing to note is C++20's coroutine support is really low level. It's designed for library authors so that they can build the kinds of things "normal" people want - tasks, generators, futures, promises, etc.
This video is the best intro I've found. It actually explains what is happening in memory, which is the only way to really understand anything in C++.
https://youtu.be/aibjUHx7vew
Also this is decent:
https://www.scs.stanford.edu/~dm/blog/c++-coroutines.html
But don't try and write a coroutine library yourself. Use something like libcoro.
Yes, in my (limited) use case with coroutines for a recursive descent generator I got it working by following this tutorial:
https://www.scs.stanford.edu/~dm/blog/c++-coroutines.html
but I was unpleasantly surprised by much extra code it required to make it run.
The Tiny Fiber library in the article looks pretty hacky right now and the amount of x64/arm specific code might cause trouble with portability, but the concept itself is intriguing. Thank you for the details.
There are much more egregious examples in computer science publishing. A paper that just repeated the words "get me off your fucking mailing list" over and over [1] was published in a journal. I also remember there being some automatic paper generators that resulted in several publications several years back. This is 100% an issue with bogus for-profit publishing, not with any particular area of study.
[1] http://www.scs.stanford.edu/~dm/home/papers/remove.pdf
Thank you for this pointer. I have been studying coroutines off and on for a while and my google/ddg foo is weak and did not find this. Or maybe google/ddg are getting weak. Sadness. I was using David Mazières' tutorial[1] but was still puzzled about the seemingly magical promise_type/coroutine_handle conversions that are nicely explained here.
[1] https://www.scs.stanford.edu/~dm/blog/c++-coroutines.html