We only need to store these positions when they don't match the original data set.
How can you tell that the third column transformed positions don't match the original data set without actually doing the transformation?
We only need to store these positions when they don't match the original data set.
How can you tell that the third column transformed positions don't match the original data set without actually doing the transformation?
versionDiff
A lot of the magic of this merge seems to hide in this versionDiff function, worth outlining the rough process at least. From the code it seems like it produces the least common ancestor version and is considered empty iff the versions are the same
seq
This to me smells a little fishy?
Without seq or any sort of indication of causal dependencies (e.g. origin/originLeft/originRight), how do we know how to properly order remote operations?
I'm guessing we encode some of this information in the ID field but this is not obvious
I'm going to keep reading but this raised a flag in my head
merges happen
Would be good context to get additional info on how often merges actually happen in real editing traces, I actually don't have a good sense of this. Maybe like 5% of ops are concurrent?
~8x faster than any other CRDT
O(n) for n ops instead of O(n^2)?
Its not obvious how you would implement something like Git's branches on top of a list CRDT.
I suspect you could uniquely identify the 'time frontier' of a branch with a list of the current 'heads' of the causal tree (anything without causal dependents). Then, we just traverse backwards from each of the heads to the root to get a set of operations that make up that 'branch'. I guess this would be like column 2.5
In Yjs that looks like this:
Just saying doubly-linked list probably is more illustrative for most here
list structure
had to read this twice because in my head, this second column is usually an arbitrary datastructure that the CRDT implementation chooses (e.g. a semilattice, tree, list, etc.)
thought keeping it as list for consistency with examples given so far also makes sense
simple and fast
What's the time complexity on OT? Fast compared to CRDTs?
A table listing time complexity for operations like 1. insert local edit 2. insert remote edit with no conflicts 3. insert remote edit with conflicts would be super useful
Rather than sorting everything by time (when), the middle list sorts everything based on where it would appear in the final document. (Well, where it would appear if nothing ever got deleted).
I'm just trying to mentally reconcile the lists with my own internal mental model for CRDTs, let me know if this is correct
The first column is what actually happened. I typed "hello" at position 1000 of the document.
What clicked for me when thinking about the differences between centralized text editing vs peer-to-peer text editing is that centralized text editing only has one primary site for changes (where the order is determined by the server) whereas peer-to-peer text editing has each peer as its own primary site (and thus we need some way of transforming operations between different sites)
I wonder if that would be good context to try and explain here to help contextual what is going on in the columns here
Below is the causal graph
Is this derived from the commit history? How are these related?
From there, I call for designing toward governable stacks at the level of communities.
I would love to read this chapter
One is Arturo Escobar’s framework of “designs for the pluriverse,” which insists that no single design can serve all people and cultures, and that we should regard design as an exercise in historical consciousness and multiplicity.
Going to call attention to some of the Verses work which may be relevant!
presents an opportunity for reimagining networks along more democratic lines.
Would like to see acknowledgement of pre-Web3 networks that embodied democratic design (e.g. SMTP and email)
The tools themselves must be different.
Tools for Conviviality one might say :)
If democracy is not a specific organism so much as an evolving symbiosis, then we can allow ourselves to imagine all the many possible feedback loops we have been too long neglecting, that we could notice and sense
I would love to see a section arguing against Plato's Ship of State
"Because large sailing vessels by their very nature need to be steered with a firm hand, sailors must yield to their captain's commands; no reasonable person believes that ships can be run democratically"
How can it be that everyone can be qualified to determine the direction of the group?
Ultimately power rested with me and whoever else’s accounts had admin privileges. What would it mean for other users to hold us admins accountable?
Digital permissions structures almost always involve a 'passing down' or granting of permissions from people already in power. How may this consolidate existing/old power? What are alternate models?
Nothing about this in particular, just thinking out loud
Additionally, mounting evidence suggests that users perceive online platforms themselves as unaccountable polities, resulting from experiences of arbitrary rule enforcement, a lack of due process, and an absence of sensitivity to context
Ali Alkhatib's To Live In Their Utopia is also a great supplementary read to these: https://dl.acm.org/doi/fullHtml/10.1145/3411764.3445740
The policy structures that regulate online life should shift from a paradigm of external imposition to one of fostering vibrant and accountable self-governance.
The late Christopher Alexander's A City Is Not a Tree has a lot of great excerpts on this! What happens when we allow for relations to happen between each other rather than top down?
"Whenever we have a tree structure, it means that within this structure no piece of any unit is ever connected to other units, except through the medium of that unit as a whole.
The enormity of this restriction is difficult to grasp. It is a little as though the members of a family were not free to make friends outside the family, except when the family as a whole made a friendship."
self-govern
I assume self-govern here means that ability for a group of people to govern themselves but a more formal definition here may be useful so we don't need to guess
quotidian
mundane or informal might be a better word here?
What happened to the picnic when it went online? This is a version of the questions many of us find ourselves asking over and over, as one scene of social life after another migrates to digital networks—our workplaces and markets, our classes and clubs, our money and family, our religion and politics. The answers, as above, are never straightforward. But they are increasingly consequential.
I really love how the prose flowed into this introduction, I'm really invested!
The air begins to smell of petrichor as moisture fills the pores of stones and dirt, releasing as aerosols the oils they have been holding inside them. By then, most of the birds and squirrels nearby already know what is coming from the changing barometric pressure, and they are back in their nests. The tree alters the chemicals oozing from its roots, which the mycelial networks underneath transmit across that section of the park. Worms weaving among them feel the moisture and move upward toward the surface, into the rain that others are trying to escape.
This is a lovely piece of prose but unsure how this adds to the part about rough consensus emerging from the group. Is the point here that there are non-human factors at play?