sbazerque

Did you read the remark at the end of my comment? In the practical cases I was exploring, that combinatorial explosion does not happen. It's relaxed in the sense that it is coordination-free.

> A program P is monotonic if for any input sets S,T where S ⊆ T, P(S) ⊆ P(T).

> A program is monotonic if, when you run it on a subset of its inputs, you get a subset of its outputs. As you run it on more data, the set of true things may grow, but it never shrinks.

Yeah, this framework seems powerful.

Something I find interesting is that you can get monotonic (and therefore coordination-free) relaxations of arbitrary problems. In extremis, you can derive a relaxed version P' thus

P'(S) = {<s, P(s)> | s ⊆ S}

and now

P'(S) ⊆ P'(T) if S ⊆ T for _any_ (well defined) P

This seems tautological but in some cases a relaxed version is good enough: it gives you convergence and eventual consistency in a coordination-free setting, at the cost of maybe having to roll back some results. And when it doesn't, it gives you a coherent model of what to make of the situation until coordination yields a definitive answer.

I wrote about this idea here: https://www.hyperhyperspace.org/report.html#conflict-resolut...

But that was like last week, haven't really put this in practice yet.

In those examples what is being processed are partially-ordered operational logs, but it's essentially the same (just that whenever S ⊆ T there, what you're seeing is an extension of an op log, which is a bit more intuitive).

Rilke is a must!!! I loved his Duino Elegies.

The case I found more worrisome is you follow someone, they then start using a new domain, and now it seems you're following a different handle (IDK if handles are immutable in Twitter, maybe they are not?).

Maybe BlueSky could offer a registrar that would do steps 1 & 2 for you transparently upon domain purchase.

So the domain is just a shortcut for the DID, in practice?

That's interesting!

And you're actually following the DID. I wonder how you present this to folks so it's understandable.

This sounds a bit like those stories about Kodak having a digital camera before anybody else did, and they just fearfully watched the thing from a distance doing nuthing until someone else brought it to market and ended the party for them.

May be an entirely different thing this time of course. But still...

Yeah, markets can be irrational, and markets know it, and play crazy games over themselves.

Maybe comm protocols?

I think this is the schema system you're asking for: https://www.hyperhyperspace.org/

(specifically, the data representation part)

In the 2000s we spoke about distributed operating systems (Inferno, etc.). That's where systems research seemed to be headed, yet that never really took off. But maybe we're revisiting the concept now, just coming down from the layer above (e.g. application data types) instead of trying to rethink the OS.

I work on this [1], it kinda looks like systems software, and it doesn't feel stagnant. But then, nobody uses it (yet - I hope).

And there's a plethora of similar ideas (DAT, OrbitDB, etc.).

[1] https://www.hyperhyperspace.org

Arithmetic is usually formalized using first order logic (that's what Godel did in his incompleteness paper, for example).

That means that one can write formulas quantifying only over numbers (that's what's done for the axioms defining addition and multiplication), but in order to get recursion, one needs to use infinite many axioms, one for each predicate P, saying:

if P(0) and (∀n)P(n) => P(n+1) then (∀n) P(n)

Intuitively, this gets us that all the numbers that can be reached starting from zero by using the "+1" operation will follow the rules of arithmetic.

But it does not guarantee that all numbers _can_ be reached this way. In the standard model, the one we have in mind, that is the case, but it turns out that there are constructions like this

0, 1, 2, ... -2', -1', 0', 1', 2' ...

having numbers that came after the ones in the standard model, but that cannot be reached by applying "+1" a finite number of times, where all the axioms of arithmetic are also true, and are therefore also models of arithmetic.

Some formulas are going to be true in one and false in the other, but all those are independent of the axioms of arithmetic. The study of formal methods in mathematics and their limitations is truly fascinating.

The Internet became mainstream because folks could use modems and phone landlines (circuit switching technology, that the new TCP/IP end-to-end packet switching stack would eventually replace) to get online.

The path for mass adoption of the new, p2p and interoperable technologies is the same: make them work on web browsers (using the browser as a full peer, not a client). It is the ubiquitous VM: JavaScript, WASM, IndexedDB, WebRTC+WebSockets, all the pieces are there.

The building blocks for a representation / data model are all in the air as well: CRDTs, Merkle-ized structures, content-based addressing, etc.

I'm a believer.

Not all CRDT libraries focus on text editing. For example, I'm working on a Byzantine fault tolerant general-purpose data sync library loosely based on CRDTs: https://www.hyperhyperspace.org

I'm finding it painfully difficult but it is evolving steadily.

Not all decentralization projects are based on scarcity, but those that do tend to get the most publicity - regrettably.

Making the network information aware is the next Internet infra problem.

This may be one of those famous last words, but friend, I do my own electrical work.

Hyper Hyper Space [1] is a library for modeling distributed data structures that uses operational CRDTs represented over a Merkle-DAG (using the partial order defined by causal relationships, like the paper describes).

It is also designed to work in a Byzantine environment (it can run inside a browser, using WebCrypto, WebRTC, etc. to connect to untrusted peers over the open internet).

[1] https://www.hyperhyperspace.org

I think the PC analogy is solid. I think the observation that we need a way to permissionly interact with data is spot-on, and I agree that that could bring a second wave of value creation and innovation.

Think of having a Facebook-like social graph, not controlled by Facebook. Or a merchant aggregation system like Amazon's without Amazon. A system not driven by maximizing exposure monetization (via ads, paid placement, etc.) but by something like a Nash equilibrium that maximizes value creation for participants.

This is what I work on, and I think it can be done.

But "the signer" here is a cryptographic identity, that may be present in more than one device. So, even when conceptually it is just one entity, in practice it may be several computers doing something independently, and one may need the result to be the same given identical inputs.

Exactly this. You need deterministic serialization, because you need to be sure that when the _same_ object is constructed in different settings, it is going to hash consistently. In Hyper Hyper Space [1], the set of basic types as well as the composition primitives used to construct all data structures have built-in deterministic serialization, just for this reason (e.g. a set will serialize into a deterministically ordered list, etc.)

[1] https://www.hyperhyperspace.org

Forget blockchains. TCP/IP, BGP, DNS, etc. they are all fantastic. What they give us is _connectivity_.

The problem is commerce (Amazon et al), search (Google), social (Facebook), etc. or, in general, the information layer built on top. David Clark said (in 1992!)

"The network as an Information Mesh. An old goal, not yet achieved."

The information theoretic and algorithmic ideas have matured (in no small part due to cryptocurrencies, yes, among other things).It's time to build that information mesh. I want a social identity that's not tied to a particular product/company. I want to shop online using a distributed protocol where reputation is independent of the platform. I want a search engine that can validate the identity and verify the integrity of the content it indexes. We can build such a thing now.

I'm thinking there's an interesting parallel between our browser-based p2p project [1] and cloudflare workers / DurableObjects. Instead of DurableObjects, we got HashedObjects [2], and instead of workers running on an edge network somewhere, we got in-browser p2p nodes running a browser-to-browser mesh network.

In general, what they do with infra, we do with cryptography & datatypes.

[1] Hyper Hyper Space: https://www.hyperhyperspace.org

[2] HashedObject: https://github.com/hyperhyperspace/hyperhyperspace-core/blob...

Hyper Hyper Space!

https://www.hyperhyperspace.org/whitepaper

Thank you for your feedback!

There are other projects that take an approach similar to what you're describing (Automerge and its derivatives, mainly).

I guess there is a distinction between distributed databases and permission-less p2p applications. Having a data center where you can trust the compute nodes running your distributed database is very different than having random untrusted peers over the net. But maybe data validation can be done in a less intrusive way, something like what Automerge does for JSON merging (maybe in a typed setting?).

That said, hyper-hyper-space is still work in progress, once we have a proper library of container types programming will be a bit more intuitive. Or so I hope, at least.

I agree with the author on the merits of the file abstraction, but I think the concept should be updated for networked devices. We need file formats that support both offline usage and seamless sync over the network.

For example, here I use a merkle DAG-based file format to represent CRDT-like types:

https://www.hyperhyperspace.org

The resulting abstraction can be universally looked up using a hash (or short sequence of words), can be modified offline and synchronized flawlessly. It's still WIP (for example, you still can't export it to an actual file, hehe).

from 10000ft away that has the feeling of op-based CRDTs

I like the idea of keeping HTML's document-centric original design, but accessing the documents using p2p protocols (instead of the client-server model used on the web).

I'm working on an open-source implementation of this idea at https://www.hyperhyperspace.org

The basic internetworking protocols are fairly decentralized: access is ubiquitous and reasonably cheap.

The handful of platforms we use to actually interact with each other over the net, on the other hand, have taken over the web. There's little competition, and most are on the verge of government intervention.

It's the other way around: the Internet needs to be rescued from the web.

Or Hyper Hyper Space:

https://www.hyperhyperspace.org

I think he's not - when you look at it from the point of view of someone who wants to buy search advertisements.

Duck Duck Go doesn't come nearly close to the kind of reach Google has.