toomim

Complex Message Transfer Protocol

Good point. You don't even need to rename the upstream project. Just create a new project, and get the code there. Since it's open source, it will eventually make its way into the upstream libwacom as well.

AT does have instances. They are just grouped differently.

In BlueSky, there is only one single "AppView" instance in the entire network. There is one instantiated "Firehose". Each user can instance his own "PDS".

In ActivityPub/Mastadon, the instances are "sender's server" vs "receiver's server."

The difference isn't that there aren't "instances" in AT proto. It's just that the instances are segmented differently.

Because tribalism. NAACP is lefty, and Musk is righty. So they fight.

I just installed it, but I can't get it to switch spaces, or show the grid overlay. It just beeps at me with the "you can't do that" beep. When I click "Add Desktop", it says "Could Not Add Desktop" and "GridLion could not read the current Spaces for this display."

This is a M1 macbook air. I really want to try this.

It's compiled to wasm for "performance", but...

1. WASM FFI has a big overhead when interacting with the javascript DOM.

2. Any DOM UI has a big overhead compared to a canvas.

I would be curious to see an actual performance evaluation. This looks like it was built for the wrong tradeoff otherwise...

How do you compare this to the effort in https://braid.org, which is also a decentralized web, which adds subscriptions that can operate in a tree (or DAG) of reactive state, each with its own validator and supporting different media types, and merging with merge-types?

Freenet seems to not interoperate with the existing WWW as much, while at the same time giving more specification on a specific routing and WASM validator. The existing WWW and Braid leave those decisions up to each particular host/authority to decide.

If you like darcs, try Pijul. It's darcs' spiritual successor, and quite performant and capable.

"An AI model is incapable of that."

"Good designers will reject this."

^ Famous last words.

It released in February 2026.

How about hacking a remarkable e-ink tablet as an easy prototype? The remarkable is basically a "better paper" already.

The git porcelain is functional, like a toilet.

You can generically represent copies and renamed (aka "moves") in a CRDT, OT or CTM using a Portal: https://braid.org/meeting-62/portals

Pijul does both. It's a VCS, that is a CRDT, that preserves conflicts until a human resolves them.

Look it up: https://pijul.org

It also makes cherrypicking and rebasing wayyyy easier. You can actually add or remove any set of patches, at any time, on any peer. It's a dramatic model shift -- and is awesome.

CRDTs actually have a long history in version control.

  - The original 1977 version control system, SCCS, was a CRDT: https://braid.org/meeting-60/sccs-is-a-time-collapse

  - It called its data structure a 'weave"

  - Brahm's old project "Codeville" used a weave for version control

  - But then git blew up in popularity.

  - The project "DARCS" tried to make a robust "theory of patches," and eventually led to the development of Pijul

  - Pijul is a VCS that is a CRDT: https://pijul.org

It depends strongly on the city, and became more pronounced since covid.

Seattle is the worst. They call it the "seattle freeze." The San Francisco Bay Area became almost as bad in covid.

The south is still friendly. Austin is incredibly friendly with strangers. Miami has strong stranger vibe. NYC is still alive, too.

You can do this by (1) extending your CRDT into a CTM (see https://braid.org/time-machines) and then (2) use the antimatter algorithm (braid.org/antimatter), or something similar, for acknowledgements.

The antimatter algorithm allows peers to learn where the rest of the network has caught up to, without a central actor, or relying on consensus, across arbitrary P2P connection & disconnection events in the network. It even allows subnetworks, after a partition, to prune the history that they generate while partitioned, while still holding onto the necessary older history to reconnect with the other half of the partition.

From just 14 hours ago!?

Faster and cheaper transactions that don't get locked up by the whims of a bureaucracy. They continue to operate on non-business days.

You're fixed on just one of the 3 definitions for the word "constitution"—the one about government.

The more general definition of "constitution" is "that which constitutes" a thing. The composition of it.

If Claude has an ego, with values, ethics, and beliefs of an etymological origin, then it makes sense to write those all down as the the "constitution" of the ego — the stuff that it constitutes.

South Park predicted it AGAIN

Lovely analysis!

But one issue: it's not actually the case that "all CRDTs are OTs".

OT is the feature of Transforming and Operation. This requires two things: (1) Operations, and (2) Transforming them so that they do the same thing when applied from one place in distributed time vs. another place in distributed time.

However, there are plenty of CRDTs that (a) do not have operations, and also plenty of CRDTs that (b) do not transform operations.

Consider a typical state-based CRDT like LWW register. It does not have operations; it just has a current state: the value of the register. And it does not transform operations. It just always computes the current value of the register.

(For more on the relationship between OT and CRDT, see my notes at braid.org/meeting-111.)

Duplication isn't always bad. It's often rational. I wrote an academic paper explaining why, and offering a solution:

https://invisible.college/toomim/toomim-linked-editing.pdf

Abstractions can be costly, and it is often in a programmer’s best interest to leave code duplicated instead. Specifically, we have identified the following general costs of abstraction that lead programmers to duplicate code (supported by a literature survey, programmer interviews, and our own analysis). These costs apply to any abstraction mechanism based on named, parameterized definitions and uses, regardless of the language.

1. *Too much work to create.* In order to create a new programming abstraction from duplicated code, the programmer has to analyze the clones’ similarities and differences, research their uses in the context of the program, and design a name and sequence of named parameters that account for present and future instantiations and represent a meaningful “design concept” in the system. This research and reasoning is thought-intensive and time-consuming.

2. *Too much overhead after creation.* Each new programming abstraction adds textual and cognitive overhead: the abstraction’s interface must be declared, maintained, and kept consistent, and the program logic (now decoupled) must be traced through additional interfaces and locations to be understood and managed. In a case study, Balazinska et. al reported that the removal of clones from the JDK source code actually increased its overall size [4].

3. *Too hard to change.* It is hard to modify the structure of highly-abstracted code. Doing so requires changing abstraction definitions and all of their uses, and often necessitates re-ordering inheritance hierarchies and other restructuring, requiring a new round of testing to ensure correctness. Programmers may duplicate code instead of restructuring existing abstractions, or in order to reduce the risk of restructuring in the future.

4. *Too hard to understand.* Some instances of duplicated code are particularly difficult to abstract cleanly, e.g. because they have a complex set of differences to parameterize or do not represent a clear design concept in the system. Furthermore, abstractions themselves are cognitively difficult. To quote Green & Blackwell: “Thinking in abstract terms is difficult: it comes late in children, it comes late to adults as they learn a new domain of knowledge, and it comes late within any given discipline.” [20]

5. *Impossible to express.* A language might not support direct abstraction of some types of clones: for instance those differing only by types (float vs. double) or keywords (if vs. while) in Java. Or, organizational issues may prevent refactoring: the code may be fragile, “frozen”, private, performance-critical, affect a standardized interface, or introduce illegal binary couplings between modules [41].

Programmers are stuck between a rock and hard place. Traditional abstractions can be too costly, causing rational programmers to duplicate code instead—but such code is viscous and prone to inconsistencies. Programmers need a flexible, lightweight tool to complement their other options.

It's like the loss of Radio Shack, all over again.

This paper does a good job relating OT and CRDT as the two major approaches to collaborative editing.

For anyone interested in this topic, I'm publishing a new theory on this called Collapsing Time Machines: https://braid.org/meeting-111.

This.

Brendan Eich was the Director of Mozilla. This is the guy who invented Javascript in 10 days, at Netscape, and then co-founded Mozilla, and became the technical lead. He was Chief Architect of Mozilla, then CTO of Mozilla Corporation, then CEO. He made Firefox great. This was when Mozilla was in its heyday, and passed IE in marketshare.

Then he was fired in 2014 because a bunch of people went crazy that he made a $1,000 political donation for a California ballot proposition that had nothing to do with computers.

This sent a signal that Mozilla doesn't reward technical improvements to its software — it rewards following political trends.

All of the bad stuff in Firefox started then.

I've spotted a partisan perspective.

Is there really any new-ish binary protocol these days?

HTTP/2 and HTTP/3 are binary protocols. And if you replace the JSON with CBOR, then even the payload becomes binary.

The reason for using HTTP is that the semantics are right. HTTP is a state transfer protocol, and ultimately, that's 90% of what you need for sync.

The other 10% is for subscriptions, updates, with versioning, and patches. You can get these by adding the Braid extensions (see braid.org) which upgrade HTTP from a state transfer to a state synchronization protocol. (I work on Braid.)

Why are we reading this from the AP-- clearly a member of the conflict --instead of a neutral party? Does anyone have a neutral source?

Your interpretation basically requires us to take everything Kirk said here as sarcastic.

Yeah. When he said "Just sayin'", that was his cue for sarcasm.