#ipld — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #ipld, aggregated by home.social.
-
@agowa338 "self-distract". lol. I can't say for real because i'm just getting into #ipfs and formal local-first, but I've found quite a few videos about #ipfs #ipns #ipld on youtube. published in the last 5 years or so.
You might want to check out https://www.inkandswitch.com You probably heard of them but i wanted to post it for completeness' sake.
-
@agowa338 "self-distract". lol. I can't say for real because i'm just getting into #ipfs and formal local-first, but I've found quite a few videos about #ipfs #ipns #ipld on youtube. published in the last 5 years or so.
You might want to check out https://www.inkandswitch.com You probably heard of them but i wanted to post it for completeness' sake.
-
@agowa338 "self-distract". lol. I can't say for real because i'm just getting into #ipfs and formal local-first, but I've found quite a few videos about #ipfs #ipns #ipld on youtube. published in the last 5 years or so.
You might want to check out https://www.inkandswitch.com You probably heard of them but i wanted to post it for completeness' sake.
-
@agowa338 "self-distract". lol. I can't say for real because i'm just getting into #ipfs and formal local-first, but I've found quite a few videos about #ipfs #ipns #ipld on youtube. published in the last 5 years or so.
You might want to check out https://www.inkandswitch.com You probably heard of them but i wanted to post it for completeness' sake.
-
@agowa338 "self-distract". lol. I can't say for real because i'm just getting into #ipfs and formal local-first, but I've found quite a few videos about #ipfs #ipns #ipld on youtube. published in the last 5 years or so.
You might want to check out https://www.inkandswitch.com You probably heard of them but i wanted to post it for completeness' sake.
-
@DimlyLitCorners got some updates from #IPFS leadership on BlueSky:
The crypto algorithm that IPFS uses for public keys and signing mutable names in #IPNS is getting added to #WebCryptography https://groups.google.com/a/chromium.org/g/blink-dev/c/T2kriFdjXsg/m/ZeD_PoLXBwAJ?pli=1
There is a draft spec for CBOR which IPFS uses to store structured data int he #IPLD graph https://datatracker.ietf.org/doc/draft-caballero-cbor-cborc42/
They are discussing it at the #IETF meeting this week in Spain
It seems they are breaking IPFS up into smaller pieces to get it through standards bodies more easily!
-
@DimlyLitCorners got some updates from #IPFS leadership on BlueSky:
The crypto algorithm that IPFS uses for public keys and signing mutable names in #IPNS is getting added to #WebCryptography https://groups.google.com/a/chromium.org/g/blink-dev/c/T2kriFdjXsg/m/ZeD_PoLXBwAJ?pli=1
There is a draft spec for CBOR which IPFS uses to store structured data int he #IPLD graph https://datatracker.ietf.org/doc/draft-caballero-cbor-cborc42/
They are discussing it at the #IETF meeting this week in Spain
It seems they are breaking IPFS up into smaller pieces to get it through standards bodies more easily!
-
@DimlyLitCorners got some updates from #IPFS leadership on BlueSky:
The crypto algorithm that IPFS uses for public keys and signing mutable names in #IPNS is getting added to #WebCryptography https://groups.google.com/a/chromium.org/g/blink-dev/c/T2kriFdjXsg/m/ZeD_PoLXBwAJ?pli=1
There is a draft spec for CBOR which IPFS uses to store structured data int he #IPLD graph https://datatracker.ietf.org/doc/draft-caballero-cbor-cborc42/
They are discussing it at the #IETF meeting this week in Spain
It seems they are breaking IPFS up into smaller pieces to get it through standards bodies more easily!
-
@DimlyLitCorners got some updates from #IPFS leadership on BlueSky:
The crypto algorithm that IPFS uses for public keys and signing mutable names in #IPNS is getting added to #WebCryptography https://groups.google.com/a/chromium.org/g/blink-dev/c/T2kriFdjXsg/m/ZeD_PoLXBwAJ?pli=1
There is a draft spec for CBOR which IPFS uses to store structured data int he #IPLD graph https://datatracker.ietf.org/doc/draft-caballero-cbor-cborc42/
They are discussing it at the #IETF meeting this week in Spain
It seems they are breaking IPFS up into smaller pieces to get it through standards bodies more easily!
-
@DimlyLitCorners got some updates from #IPFS leadership on BlueSky:
The crypto algorithm that IPFS uses for public keys and signing mutable names in #IPNS is getting added to #WebCryptography https://groups.google.com/a/chromium.org/g/blink-dev/c/T2kriFdjXsg/m/ZeD_PoLXBwAJ?pli=1
There is a draft spec for CBOR which IPFS uses to store structured data int he #IPLD graph https://datatracker.ietf.org/doc/draft-caballero-cbor-cborc42/
They are discussing it at the #IETF meeting this week in Spain
It seems they are breaking IPFS up into smaller pieces to get it through standards bodies more easily!
-
-
-
-
-
-
Agregore 2.12.0 - Peersky theme compat, Local AI onboarding improvements
=> https://agregore.mauve.moe
A minimal web browser for the distributed web
- Enable people to make and use local first apps using the web
- Be minimal (fewer built-in features, leave more to the OS)
- Be open to anything p2p / decentralized / local-first
- Rely on web extensions for extra functionality
- Work with mesh networks / Bluetooth Low Energy networks
Changelog:
=> https://github.com/AgregoreWeb/agregore-browser/releases/tag/v2.12.0
#IPFS #IPLD #Hypercore #Gemini #SSB #BitTorrent -
Agregore 2.8.2 - Font Based Syntax Highlighting
=> https://agregore.mauve.moe
A minimal web browser for the distributed web
- Enable people to make and use local first apps using the web
- Be minimal (fewer built-in features, leave more to the OS)
- Be open to anything p2p / decentralized / local-first
- Rely on web extensions for extra functionality
- Work with mesh networks / Bluetooth Low Energy networks
Changelog:
=> https://github.com/AgregoreWeb/agregore-browser/releases/tag/v2.8.2
#IPFS #IPLD #Hypercore #Gemini #SSB #BitTorrent -
Agregore 2.7.0 - Settings Page
=> https://agregore.mauve.moe
A minimal web browser for the distributed web
- Enable people to make and use local first apps using the web
- Be minimal (fewer built-in features, leave more to the OS)
- Be open to anything p2p / decentralized / local-first
- Rely on web extensions for extra functionality
- Work with mesh networks / Bluetooth Low Energy networks
Changelog:
=> https://github.com/AgregoreWeb/agregore-browser/releases/tag/v2.7.0
#IPFS #IPLD #Hypercore #Gemini #SSB #BitTorrent -
Agregore 2.7.0 - Settings Page
=> https://agregore.mauve.moe
A minimal web browser for the distributed web
- Enable people to make and use local first apps using the web
- Be minimal (fewer built-in features, leave more to the OS)
- Be open to anything p2p / decentralized / local-first
- Rely on web extensions for extra functionality
- Work with mesh networks / Bluetooth Low Energy networks
Changelog:
=> https://github.com/AgregoreWeb/agregore-browser/releases/tag/v2.7.0
#IPFS #IPLD #Hypercore #Gemini #SSB #BitTorrent -
Sacrificed my night to the productivity gods. The output is the beginnings of the "ipti" CLI which is a tool for authoring / reading #IPLD databases based on my impl of the Prolly Tree spec.
It's not ready for release yet but this will make it easier to integrate into pipelines with bash or other languages without having to touch golang directly.
Indexer library here: https://github.com/RangerMauve/ipld-prolly-indexer
Note I don't have a standard for replicating over the network so it currently reads/writes CAR files
-
Sacrificed my night to the productivity gods. The output is the beginnings of the "ipti" CLI which is a tool for authoring / reading #IPLD databases based on my impl of the Prolly Tree spec.
It's not ready for release yet but this will make it easier to integrate into pipelines with bash or other languages without having to touch golang directly.
Indexer library here: https://github.com/RangerMauve/ipld-prolly-indexer
Note I don't have a standard for replicating over the network so it currently reads/writes CAR files
-
Sacrificed my night to the productivity gods. The output is the beginnings of the "ipti" CLI which is a tool for authoring / reading #IPLD databases based on my impl of the Prolly Tree spec.
It's not ready for release yet but this will make it easier to integrate into pipelines with bash or other languages without having to touch golang directly.
Indexer library here: https://github.com/RangerMauve/ipld-prolly-indexer
Note I don't have a standard for replicating over the network so it currently reads/writes CAR files
-
Sacrificed my night to the productivity gods. The output is the beginnings of the "ipti" CLI which is a tool for authoring / reading #IPLD databases based on my impl of the Prolly Tree spec.
It's not ready for release yet but this will make it easier to integrate into pipelines with bash or other languages without having to touch golang directly.
Indexer library here: https://github.com/RangerMauve/ipld-prolly-indexer
Note I don't have a standard for replicating over the network so it currently reads/writes CAR files
-
Sacrificed my night to the productivity gods. The output is the beginnings of the "ipti" CLI which is a tool for authoring / reading #IPLD databases based on my impl of the Prolly Tree spec.
It's not ready for release yet but this will make it easier to integrate into pipelines with bash or other languages without having to touch golang directly.
Indexer library here: https://github.com/RangerMauve/ipld-prolly-indexer
Note I don't have a standard for replicating over the network so it currently reads/writes CAR files
-
Soon it becomes apparent that, wait, that same electrode group collects multiple timeseries, so it should probably be its own
thingthat I can reference in multiple places. So the ability to create references is added, and the ability to create anonymous sub-things is also retained, because not everything is reused.so electrode is its own thing, but it too has its own anonymous untyped things, and I want to reference those. So now I need to create a reference with subselection - "this electrode within electrode group x." This is often done by creating another anonymous subthing within the referring thing - "a table that contains indices with which I select from the thing I'm referring to." When you un-nest the schema, these kinds of references are actually most of the anonymous classes.
This is a pretty tight analogical map to blank nodes, this tension in #RDF where "everything should be uniquely, globally identifiable" but "actually not literally everything because that would be ridiculous." And blank nodes have caused a ton of work to be needed to eg. canonicalize graphs so you can automatically assign unique names to things.
See also #IPLD which makes some different choices, notably being to treat every subgraph as ordered even though graphs don't have an intrinsic ordering: https://ipld.io/design/tricky-choices/ordering/
(Side note every project should have a "tricky choices" section in the docs. Props to protocol labs for that) -
Soon it becomes apparent that, wait, that same electrode group collects multiple timeseries, so it should probably be its own
thingthat I can reference in multiple places. So the ability to create references is added, and the ability to create anonymous sub-things is also retained, because not everything is reused.so electrode is its own thing, but it too has its own anonymous untyped things, and I want to reference those. So now I need to create a reference with subselection - "this electrode within electrode group x." This is often done by creating another anonymous subthing within the referring thing - "a table that contains indices with which I select from the thing I'm referring to." When you un-nest the schema, these kinds of references are actually most of the anonymous classes.
This is a pretty tight analogical map to blank nodes, this tension in #RDF where "everything should be uniquely, globally identifiable" but "actually not literally everything because that would be ridiculous." And blank nodes have caused a ton of work to be needed to eg. canonicalize graphs so you can automatically assign unique names to things.
See also #IPLD which makes some different choices, notably being to treat every subgraph as ordered even though graphs don't have an intrinsic ordering: https://ipld.io/design/tricky-choices/ordering/
(Side note every project should have a "tricky choices" section in the docs. Props to protocol labs for that) -
Soon it becomes apparent that, wait, that same electrode group collects multiple timeseries, so it should probably be its own
thingthat I can reference in multiple places. So the ability to create references is added, and the ability to create anonymous sub-things is also retained, because not everything is reused.so electrode is its own thing, but it too has its own anonymous untyped things, and I want to reference those. So now I need to create a reference with subselection - "this electrode within electrode group x." This is often done by creating another anonymous subthing within the referring thing - "a table that contains indices with which I select from the thing I'm referring to." When you un-nest the schema, these kinds of references are actually most of the anonymous classes.
This is a pretty tight analogical map to blank nodes, this tension in #RDF where "everything should be uniquely, globally identifiable" but "actually not literally everything because that would be ridiculous." And blank nodes have caused a ton of work to be needed to eg. canonicalize graphs so you can automatically assign unique names to things.
See also #IPLD which makes some different choices, notably being to treat every subgraph as ordered even though graphs don't have an intrinsic ordering: https://ipld.io/design/tricky-choices/ordering/
(Side note every project should have a "tricky choices" section in the docs. Props to protocol labs for that) -
Soon it becomes apparent that, wait, that same electrode group collects multiple timeseries, so it should probably be its own
thingthat I can reference in multiple places. So the ability to create references is added, and the ability to create anonymous sub-things is also retained, because not everything is reused.so electrode is its own thing, but it too has its own anonymous untyped things, and I want to reference those. So now I need to create a reference with subselection - "this electrode within electrode group x." This is often done by creating another anonymous subthing within the referring thing - "a table that contains indices with which I select from the thing I'm referring to." When you un-nest the schema, these kinds of references are actually most of the anonymous classes.
This is a pretty tight analogical map to blank nodes, this tension in #RDF where "everything should be uniquely, globally identifiable" but "actually not literally everything because that would be ridiculous." And blank nodes have caused a ton of work to be needed to eg. canonicalize graphs so you can automatically assign unique names to things.
See also #IPLD which makes some different choices, notably being to treat every subgraph as ordered even though graphs don't have an intrinsic ordering: https://ipld.io/design/tricky-choices/ordering/
(Side note every project should have a "tricky choices" section in the docs. Props to protocol labs for that) -
Soon it becomes apparent that, wait, that same electrode group collects multiple timeseries, so it should probably be its own
thingthat I can reference in multiple places. So the ability to create references is added, and the ability to create anonymous sub-things is also retained, because not everything is reused.so electrode is its own thing, but it too has its own anonymous untyped things, and I want to reference those. So now I need to create a reference with subselection - "this electrode within electrode group x." This is often done by creating another anonymous subthing within the referring thing - "a table that contains indices with which I select from the thing I'm referring to." When you un-nest the schema, these kinds of references are actually most of the anonymous classes.
This is a pretty tight analogical map to blank nodes, this tension in #RDF where "everything should be uniquely, globally identifiable" but "actually not literally everything because that would be ridiculous." And blank nodes have caused a ton of work to be needed to eg. canonicalize graphs so you can automatically assign unique names to things.
See also #IPLD which makes some different choices, notably being to treat every subgraph as ordered even though graphs don't have an intrinsic ordering: https://ipld.io/design/tricky-choices/ordering/
(Side note every project should have a "tricky choices" section in the docs. Props to protocol labs for that) -
Is there an alternative to #ipfs and #ipld out there?
Essentially I want a way to build a DAG/Merkle Tree, a content-addressable storage, where I can define the node format, can store binary data and can find data from remotes via hashes...
All of that is offered by ipfs 😭 but I don't want to write go or javascript for that, I want to be able to use #rust
I am almost at the point where I think of trying #typescript and use the JS implementation of ipfs... almost.
-
Is there an alternative to #ipfs and #ipld out there?
Essentially I want a way to build a DAG/Merkle Tree, a content-addressable storage, where I can define the node format, can store binary data and can find data from remotes via hashes...
All of that is offered by ipfs 😭 but I don't want to write go or javascript for that, I want to be able to use #rust
I am almost at the point where I think of trying #typescript and use the JS implementation of ipfs... almost.
-
Is there an alternative to #ipfs and #ipld out there?
Essentially I want a way to build a DAG/Merkle Tree, a content-addressable storage, where I can define the node format, can store binary data and can find data from remotes via hashes...
All of that is offered by ipfs 😭 but I don't want to write go or javascript for that, I want to be able to use #rust
I am almost at the point where I think of trying #typescript and use the JS implementation of ipfs... almost.
-
Is there an alternative to #ipfs and #ipld out there?
Essentially I want a way to build a DAG/Merkle Tree, a content-addressable storage, where I can define the node format, can store binary data and can find data from remotes via hashes...
All of that is offered by ipfs 😭 but I don't want to write go or javascript for that, I want to be able to use #rust
I am almost at the point where I think of trying #typescript and use the JS implementation of ipfs... almost.
-
Is there an alternative to #ipfs and #ipld out there?
Essentially I want a way to build a DAG/Merkle Tree, a content-addressable storage, where I can define the node format, can store binary data and can find data from remotes via hashes...
All of that is offered by ipfs 😭 but I don't want to write go or javascript for that, I want to be able to use #rust
I am almost at the point where I think of trying #typescript and use the JS implementation of ipfs... almost.
-
starting with research data is a constrained problem to get some of the fundamentals of data structures, transport, and interop down so that in the next phase we can build identity, peer federation, and communication on top of that. we want to be able to handle bigg blobs of bits as well as liddel messages, and so making a p2p transport layer for RDF-like things leads naturally into the second phase goal of bridging the fediverse which runs on #JSONLD to p2p.
I still am not committed to actually building for RDF, want to learn from prior art without being weighed down by 20+ years of convoluted technical history, but there is a lot to learn about linking graphs there. I think one of the main things I am uncommitted to is needing globally unique URIs for everything, rather than having some things uniquely identifiable (eg. a dataset, a post) with relative locations for other things. That way you can make containers for encryption - peers can refer to the content hash of the encrypted subgraph as location for querying, zero-knowledge mirroring, etc. as well as opaque references to the graph content itself for peers that can decrypt it, but those inner-locations can't be resolved by peers that can't decrypt.
that is still a very unfinished thought, but it's a big missing piece in related technologies like #IPFS where everything must be addressable by CID. its arguably the need that #IPNS and #IPLD are intended to backfill
-
starting with research data is a constrained problem to get some of the fundamentals of data structures, transport, and interop down so that in the next phase we can build identity, peer federation, and communication on top of that. we want to be able to handle bigg blobs of bits as well as liddel messages, and so making a p2p transport layer for RDF-like things leads naturally into the second phase goal of bridging the fediverse which runs on #JSONLD to p2p.
I still am not committed to actually building for RDF, want to learn from prior art without being weighed down by 20+ years of convoluted technical history, but there is a lot to learn about linking graphs there. I think one of the main things I am uncommitted to is needing globally unique URIs for everything, rather than having some things uniquely identifiable (eg. a dataset, a post) with relative locations for other things. That way you can make containers for encryption - peers can refer to the content hash of the encrypted subgraph as location for querying, zero-knowledge mirroring, etc. as well as opaque references to the graph content itself for peers that can decrypt it, but those inner-locations can't be resolved by peers that can't decrypt.
that is still a very unfinished thought, but it's a big missing piece in related technologies like #IPFS where everything must be addressable by CID. its arguably the need that #IPNS and #IPLD are intended to backfill
-
starting with research data is a constrained problem to get some of the fundamentals of data structures, transport, and interop down so that in the next phase we can build identity, peer federation, and communication on top of that. we want to be able to handle bigg blobs of bits as well as liddel messages, and so making a p2p transport layer for RDF-like things leads naturally into the second phase goal of bridging the fediverse which runs on #JSONLD to p2p.
I still am not committed to actually building for RDF, want to learn from prior art without being weighed down by 20+ years of convoluted technical history, but there is a lot to learn about linking graphs there. I think one of the main things I am uncommitted to is needing globally unique URIs for everything, rather than having some things uniquely identifiable (eg. a dataset, a post) with relative locations for other things. That way you can make containers for encryption - peers can refer to the content hash of the encrypted subgraph as location for querying, zero-knowledge mirroring, etc. as well as opaque references to the graph content itself for peers that can decrypt it, but those inner-locations can't be resolved by peers that can't decrypt.
that is still a very unfinished thought, but it's a big missing piece in related technologies like #IPFS where everything must be addressable by CID. its arguably the need that #IPNS and #IPLD are intended to backfill
-
starting with research data is a constrained problem to get some of the fundamentals of data structures, transport, and interop down so that in the next phase we can build identity, peer federation, and communication on top of that. we want to be able to handle bigg blobs of bits as well as liddel messages, and so making a p2p transport layer for RDF-like things leads naturally into the second phase goal of bridging the fediverse which runs on #JSONLD to p2p.
I still am not committed to actually building for RDF, want to learn from prior art without being weighed down by 20+ years of convoluted technical history, but there is a lot to learn about linking graphs there. I think one of the main things I am uncommitted to is needing globally unique URIs for everything, rather than having some things uniquely identifiable (eg. a dataset, a post) with relative locations for other things. That way you can make containers for encryption - peers can refer to the content hash of the encrypted subgraph as location for querying, zero-knowledge mirroring, etc. as well as opaque references to the graph content itself for peers that can decrypt it, but those inner-locations can't be resolved by peers that can't decrypt.
that is still a very unfinished thought, but it's a big missing piece in related technologies like #IPFS where everything must be addressable by CID. its arguably the need that #IPNS and #IPLD are intended to backfill
-
starting with research data is a constrained problem to get some of the fundamentals of data structures, transport, and interop down so that in the next phase we can build identity, peer federation, and communication on top of that. we want to be able to handle bigg blobs of bits as well as liddel messages, and so making a p2p transport layer for RDF-like things leads naturally into the second phase goal of bridging the fediverse which runs on #JSONLD to p2p.
I still am not committed to actually building for RDF, want to learn from prior art without being weighed down by 20+ years of convoluted technical history, but there is a lot to learn about linking graphs there. I think one of the main things I am uncommitted to is needing globally unique URIs for everything, rather than having some things uniquely identifiable (eg. a dataset, a post) with relative locations for other things. That way you can make containers for encryption - peers can refer to the content hash of the encrypted subgraph as location for querying, zero-knowledge mirroring, etc. as well as opaque references to the graph content itself for peers that can decrypt it, but those inner-locations can't be resolved by peers that can't decrypt.
that is still a very unfinished thought, but it's a big missing piece in related technologies like #IPFS where everything must be addressable by CID. its arguably the need that #IPNS and #IPLD are intended to backfill
-
#ipld is yet another #Linkeddata format but for content adressable data in decentralised systems. DWN use IPLDs as a schema
https://www.youtube.com/watch?v=totVQXYS1N8 -
#ipld is yet another #Linkeddata format but for content adressable data in decentralised systems. DWN use IPLDs as a schema
https://www.youtube.com/watch?v=totVQXYS1N8 -
#ipld is yet another #Linkeddata format but for content adressable data in decentralised systems. DWN use IPLDs as a schema
https://www.youtube.com/watch?v=totVQXYS1N8 -
#ipld is yet another #Linkeddata format but for content adressable data in decentralised systems. DWN use IPLDs as a schema
https://www.youtube.com/watch?v=totVQXYS1N8 -
J Chris from #FireproofStorage an #IPLD database https://fireproof.storage
Gifting me some hot sauce. And yes that's obviously a fire 🔥 suit, too!
-
J Chris from #FireproofStorage an #IPLD database https://fireproof.storage
Gifting me some hot sauce. And yes that's obviously a fire 🔥 suit, too!
-
J Chris from #FireproofStorage an #IPLD database https://fireproof.storage
Gifting me some hot sauce. And yes that's obviously a fire 🔥 suit, too!
-
J Chris from #FireproofStorage an #IPLD database https://fireproof.storage
Gifting me some hot sauce. And yes that's obviously a fire 🔥 suit, too!
-
ok so re-reading #IPFS paper and there are a few things I think in retrospect are undesirable about the #MerkelDAG spec. it's hard to parse them out as separable ideas because they depend on one another, but the main thing I think is how it conflates the structure of a metadata graph, the content of the graph, and the notion of authorship/identity.
In (basic) IPFS, each node contains some data and some links. the data is some unspecified binary blob, the links are all references to hashes of other nodes, and then the hash of all that identifies the node. There are some abstractions like flattened trees that can represent n-depth links, but that's the gist. I'm refreshing myself, so correct me where I'm wrong.
This makes traversing the graph expensive from a naive (cacheless) state- you have to fetch each node and parse its links serially, and since there isn't a notion of authorship except when used to sign a node, you might have to do the resolution process across a lot of the network instead of being able to say "ah ok this is from this identity so I should ask their neighborhood first"
Since the links are untyped, and because of the need for serial resolution, you can't really "plan" queries and move the query logic to the "edges" (in a networking, rather than graph parlance) of the network - the network resolution logic handles all that.
This structure also makes it so you can't "talk about" a node. A node contains its links. The links are directional, so I could make some statement about a node by pointing to it, but I can't, as a third party make a link under my identity, separate from the author and content of the node, that points from some object to another. That makes the network more like a hard drive than a social space.
Further, since links aren't typed, you have to move that metadata inside the node. This makes you need to re-hash each node more than you need to, and since "keys" for identifying different fields in the node aren't themselves links, you can't have any notion of "schema" where a term can be reused. So there isn't really a facility for being able to do graph queries like "find me this type of data whose field has this value" which restricts a whole huge range of possibilities too long to list here. This also makes knowing what the binary data inside a node is potentially impossible without out of band info, depending on how it's encoded. #IPLD and #Multiformats are intended to solve this, post-hoc.
I'll stop there for now, and save what I think could be a different model for later, but I am thinking along the lines of merging with #LinkedData #Triplets , encoding the notion of authorship into links (so that links can have an "utterance" rather than "fact" ontological status), a notion of container/contained for explicit block formation and metadata separation, and formalizing the notion of orthogonal Merkel DAGs to change the points where the content addressing happens to be able to have "graph subunits" that allow for cycles at a "complete" scope but for the purposes of hashing have no cycles. very much #WIP, still at conceptual stage haven't started writing spec yet.
-
ok so re-reading #IPFS paper and there are a few things I think in retrospect are undesirable about the #MerkelDAG spec. it's hard to parse them out as separable ideas because they depend on one another, but the main thing I think is how it conflates the structure of a metadata graph, the content of the graph, and the notion of authorship/identity.
In (basic) IPFS, each node contains some data and some links. the data is some unspecified binary blob, the links are all references to hashes of other nodes, and then the hash of all that identifies the node. There are some abstractions like flattened trees that can represent n-depth links, but that's the gist. I'm refreshing myself, so correct me where I'm wrong.
This makes traversing the graph expensive from a naive (cacheless) state- you have to fetch each node and parse its links serially, and since there isn't a notion of authorship except when used to sign a node, you might have to do the resolution process across a lot of the network instead of being able to say "ah ok this is from this identity so I should ask their neighborhood first"
Since the links are untyped, and because of the need for serial resolution, you can't really "plan" queries and move the query logic to the "edges" (in a networking, rather than graph parlance) of the network - the network resolution logic handles all that.
This structure also makes it so you can't "talk about" a node. A node contains its links. The links are directional, so I could make some statement about a node by pointing to it, but I can't, as a third party make a link under my identity, separate from the author and content of the node, that points from some object to another. That makes the network more like a hard drive than a social space.
Further, since links aren't typed, you have to move that metadata inside the node. This makes you need to re-hash each node more than you need to, and since "keys" for identifying different fields in the node aren't themselves links, you can't have any notion of "schema" where a term can be reused. So there isn't really a facility for being able to do graph queries like "find me this type of data whose field has this value" which restricts a whole huge range of possibilities too long to list here. This also makes knowing what the binary data inside a node is potentially impossible without out of band info, depending on how it's encoded. #IPLD and #Multiformats are intended to solve this, post-hoc.
I'll stop there for now, and save what I think could be a different model for later, but I am thinking along the lines of merging with #LinkedData #Triplets , encoding the notion of authorship into links (so that links can have an "utterance" rather than "fact" ontological status), a notion of container/contained for explicit block formation and metadata separation, and formalizing the notion of orthogonal Merkel DAGs to change the points where the content addressing happens to be able to have "graph subunits" that allow for cycles at a "complete" scope but for the purposes of hashing have no cycles. very much #WIP, still at conceptual stage haven't started writing spec yet.
-
ok so re-reading #IPFS paper and there are a few things I think in retrospect are undesirable about the #MerkelDAG spec. it's hard to parse them out as separable ideas because they depend on one another, but the main thing I think is how it conflates the structure of a metadata graph, the content of the graph, and the notion of authorship/identity.
In (basic) IPFS, each node contains some data and some links. the data is some unspecified binary blob, the links are all references to hashes of other nodes, and then the hash of all that identifies the node. There are some abstractions like flattened trees that can represent n-depth links, but that's the gist. I'm refreshing myself, so correct me where I'm wrong.
This makes traversing the graph expensive from a naive (cacheless) state- you have to fetch each node and parse its links serially, and since there isn't a notion of authorship except when used to sign a node, you might have to do the resolution process across a lot of the network instead of being able to say "ah ok this is from this identity so I should ask their neighborhood first"
Since the links are untyped, and because of the need for serial resolution, you can't really "plan" queries and move the query logic to the "edges" (in a networking, rather than graph parlance) of the network - the network resolution logic handles all that.
This structure also makes it so you can't "talk about" a node. A node contains its links. The links are directional, so I could make some statement about a node by pointing to it, but I can't, as a third party make a link under my identity, separate from the author and content of the node, that points from some object to another. That makes the network more like a hard drive than a social space.
Further, since links aren't typed, you have to move that metadata inside the node. This makes you need to re-hash each node more than you need to, and since "keys" for identifying different fields in the node aren't themselves links, you can't have any notion of "schema" where a term can be reused. So there isn't really a facility for being able to do graph queries like "find me this type of data whose field has this value" which restricts a whole huge range of possibilities too long to list here. This also makes knowing what the binary data inside a node is potentially impossible without out of band info, depending on how it's encoded. #IPLD and #Multiformats are intended to solve this, post-hoc.
I'll stop there for now, and save what I think could be a different model for later, but I am thinking along the lines of merging with #LinkedData #Triplets , encoding the notion of authorship into links (so that links can have an "utterance" rather than "fact" ontological status), a notion of container/contained for explicit block formation and metadata separation, and formalizing the notion of orthogonal Merkel DAGs to change the points where the content addressing happens to be able to have "graph subunits" that allow for cycles at a "complete" scope but for the purposes of hashing have no cycles. very much #WIP, still at conceptual stage haven't started writing spec yet.
-
ok so re-reading #IPFS paper and there are a few things I think in retrospect are undesirable about the #MerkelDAG spec. it's hard to parse them out as separable ideas because they depend on one another, but the main thing I think is how it conflates the structure of a metadata graph, the content of the graph, and the notion of authorship/identity.
In (basic) IPFS, each node contains some data and some links. the data is some unspecified binary blob, the links are all references to hashes of other nodes, and then the hash of all that identifies the node. There are some abstractions like flattened trees that can represent n-depth links, but that's the gist. I'm refreshing myself, so correct me where I'm wrong.
This makes traversing the graph expensive from a naive (cacheless) state- you have to fetch each node and parse its links serially, and since there isn't a notion of authorship except when used to sign a node, you might have to do the resolution process across a lot of the network instead of being able to say "ah ok this is from this identity so I should ask their neighborhood first"
Since the links are untyped, and because of the need for serial resolution, you can't really "plan" queries and move the query logic to the "edges" (in a networking, rather than graph parlance) of the network - the network resolution logic handles all that.
This structure also makes it so you can't "talk about" a node. A node contains its links. The links are directional, so I could make some statement about a node by pointing to it, but I can't, as a third party make a link under my identity, separate from the author and content of the node, that points from some object to another. That makes the network more like a hard drive than a social space.
Further, since links aren't typed, you have to move that metadata inside the node. This makes you need to re-hash each node more than you need to, and since "keys" for identifying different fields in the node aren't themselves links, you can't have any notion of "schema" where a term can be reused. So there isn't really a facility for being able to do graph queries like "find me this type of data whose field has this value" which restricts a whole huge range of possibilities too long to list here. This also makes knowing what the binary data inside a node is potentially impossible without out of band info, depending on how it's encoded. #IPLD and #Multiformats are intended to solve this, post-hoc.
I'll stop there for now, and save what I think could be a different model for later, but I am thinking along the lines of merging with #LinkedData #Triplets , encoding the notion of authorship into links (so that links can have an "utterance" rather than "fact" ontological status), a notion of container/contained for explicit block formation and metadata separation, and formalizing the notion of orthogonal Merkel DAGs to change the points where the content addressing happens to be able to have "graph subunits" that allow for cycles at a "complete" scope but for the purposes of hashing have no cycles. very much #WIP, still at conceptual stage haven't started writing spec yet.
-
ok so re-reading #IPFS paper and there are a few things I think in retrospect are undesirable about the #MerkelDAG spec. it's hard to parse them out as separable ideas because they depend on one another, but the main thing I think is how it conflates the structure of a metadata graph, the content of the graph, and the notion of authorship/identity.
In (basic) IPFS, each node contains some data and some links. the data is some unspecified binary blob, the links are all references to hashes of other nodes, and then the hash of all that identifies the node. There are some abstractions like flattened trees that can represent n-depth links, but that's the gist. I'm refreshing myself, so correct me where I'm wrong.
This makes traversing the graph expensive from a naive (cacheless) state- you have to fetch each node and parse its links serially, and since there isn't a notion of authorship except when used to sign a node, you might have to do the resolution process across a lot of the network instead of being able to say "ah ok this is from this identity so I should ask their neighborhood first"
Since the links are untyped, and because of the need for serial resolution, you can't really "plan" queries and move the query logic to the "edges" (in a networking, rather than graph parlance) of the network - the network resolution logic handles all that.
This structure also makes it so you can't "talk about" a node. A node contains its links. The links are directional, so I could make some statement about a node by pointing to it, but I can't, as a third party make a link under my identity, separate from the author and content of the node, that points from some object to another. That makes the network more like a hard drive than a social space.
Further, since links aren't typed, you have to move that metadata inside the node. This makes you need to re-hash each node more than you need to, and since "keys" for identifying different fields in the node aren't themselves links, you can't have any notion of "schema" where a term can be reused. So there isn't really a facility for being able to do graph queries like "find me this type of data whose field has this value" which restricts a whole huge range of possibilities too long to list here. This also makes knowing what the binary data inside a node is potentially impossible without out of band info, depending on how it's encoded. #IPLD and #Multiformats are intended to solve this, post-hoc.
I'll stop there for now, and save what I think could be a different model for later, but I am thinking along the lines of merging with #LinkedData #Triplets , encoding the notion of authorship into links (so that links can have an "utterance" rather than "fact" ontological status), a notion of container/contained for explicit block formation and metadata separation, and formalizing the notion of orthogonal Merkel DAGs to change the points where the content addressing happens to be able to have "graph subunits" that allow for cycles at a "complete" scope but for the purposes of hashing have no cycles. very much #WIP, still at conceptual stage haven't started writing spec yet.
