For an explanation of fork consistency, read this paper through the end of Section 3.2: SUNDR, Li et al, 2004.
SPORC attacks a classic set of problems with simple untrusted storage servers: even if clients sign the data for authenticity, evil servers might still return old versions of data, or claim the data doesn't exist, or show different clients different subsets of the data. How does SPORC deal with these attacks?
The paper says it's aimed at collaborative editing. Could the system equally well be used to support more general decentralized applications?
The protocol seems to be independent per document. Could it be applied to applications like Piazza, or e-mail, or Reddit, that have many files, owned by many users, possibly spread over many servers and storage providers? Or that are big enough or busy enough that it's not practical for every client to store the entire state and history?
Are operational transformations applicable to most applications? If an application's updates aren't suitable for operational transformations, would it still make sense to use SPORC? Which of SPORC's properties would be lost?
Is fork consistency good enough? Would it be good enough for Bitcoin? How about other decentralized applications?
Are SPORC's hash chains over the history related to block chains? Do they provide the same properties?
Does SPORC have anything corresponding to mining in block chains? If not, does it thereby lose any valuable properties?
Do block chains provide fork consistency? Do they provide stronger properties than fork consistency (e.g. do they prevent forks altogether)?
How do block chain systems manage to do without something like operational transformations?
Why does SPORC store histories, instead of just the current state?
Why do clients have to remember the entire history? Is it OK if clients discard old history? If the server discards old history?
For old objects that have seen lots of updates, is it a problem that the history grows large? Does a client that hasn't read an object before have to fetch and verify the entire history before it can use the object?
What is causal consistency? Why is it useful for SPORC to provide it? Does it seem necessary (or sufficient) for decentralized applications?
Does automatic repair of forks with OT seem like a good idea? If the original fork was part of an attack (perhaps something analogous to double-spending in Bitcoin), will joining the fork incorrectly make it seem as if nothing is wrong?
Are SPORC's mechanisms related to Sirius's techniques to guarantee fresh meta-data? More or less powerful?