Tim Berners-Lee SOLID project maybe implementation with IPFS?

#1

Hello,

I see a new which talk Tim Berners-Lee works on new project SOLID. It’s specs to propose approach on decentralized web application. The goal is permit to enduser to get ownership personal data.

I think it might be interesting to see how far IPFS can help or used to do that

what do you think ?

Regards

1 Like
ActivityPub integration with IPFS
#2

I’m still very unclear on how SOLID and IPFS compare. It seems that SOLID needs to be built on something like IPFS, but have they come up with their own version of IPFS or something? The site doesn’t have a lot of useful details…

#3

Some quick browsing of SOLID developer resources has revealed a little more.

The technical spec makes it sound as though it does not actually compete with IPFS, since everything seems to be done in the usual single-server-over-HTTP regime, which makes me think that it should be able to be used on top of IPFS instead with minimal pain. Really the decentralized part seems to be the access to the data, not the storage of the data itself, which is a key value-add for IPFS.

One unfortunate thing is that they have come up with their own version of IPLD called Linked Data.

5 Likes
#4

thx for your analyse about that yes Linked data can be compare at IPLD it’s my guess also.

Regards

#5

My high level understanding of SOLID is that it explores the potential of creating a new paradigm by proposing all data for web apps should be defined and accessed through RDF from rdf end point. So there is a universal metadesignable reusable interoperable common data layer so all applications can be built from reusable components.

It is inherently distributed in the sense that it assumes rdf end points to be available and is agnostic about the topology of endpoints.
It is an application/data protocol.

I am interested myself in building out a comparable vision but all built on top of IPFS.

2 Likes
#6

Hi gyuri,

I’m very intrestig to contributate your work to build this comparable vision on IPFS. Let me know if you intresting for bit help.

Regards

#7

I am not sure what the protocol is for connecting on this platform, and we may have some language barriers to cross, but I would very much like to discuss things with you.
My linked in profile may give you some background https://www.linkedin.com/in/gyuri-lajos/ while I read the community guidelines

#8

Solid is a set of protocol to build the Social application that produces Linked-Data, and it will guide developers to utilize Linked-Data in the future. So it’s an application-level protocol set.

For Linked-Data, there are two things related to IPFS:

  1. It should be stored in a storage layer, called POD, which may have many providers. As long as a storage provider follow the protocol ( providing some API, details here https://www.w3.org/TR/ldp-primer). So anybody can warp IPFS in his own way to build a POD to store linked data.
  2. Basically, we store linked-data in RDF on POD. But linked-data has many serialization formats, likes JSON-LD, which IPLD is comparable to.

This is my understanding to IPFS + Solid.

1 Like
#9

More reference:

https://solid.mit.edu/
https://www.w3.org/DesignIssues/CloudStorage.html



https://www.w3.org/TR/cooluris/#solutions
https://githubcom/solid/solid-spec/blob/master/solid-webid-profiles.md#public-and-private-profiles)
https://githubcom/solid/solid/blob/master/proposals/data-discovery.md)
https://www.w3.org/wiki/WebAccessControl
http://www.ruanyifeng.com/blog/2011/08/what_is_a_digital_signaturehtml)
https://docs.aws.amazoncom/zh_cn/waf/latest/developerguide/web-acl.html)
https://github.com/solid/web-access-control-spec#modes-of-access
https://www.w3.org/TR/ldp-primer/#intro-section
https://www.w3.org/2013/dwbp/wiki/RDF_AND_JSON-LD_UseCases
https://www.w3.org/TR/social-web-protocols/#subscribing
https://www.w3.org/TR/activitypub/
https://mediumcom/uport/private-data-on-public-networks-ab1086a137d8)
http://ethfans.org/posts/what-is-a-uport-identity

#10

I like Engelbart too. I think Solid will do a lot of good to human, and IPFS will make using Solid easier.

#11

Also interested in Solid on top of IPFS. Solid looks good, but I’d be looking for IPFS to maybe help backup the POD data to the IPFS network?

#12

I’m new to IPFS, for what I can understand, I agree that “more or less” SOLID could be implemented on the top of IPFS. Some features of Linked Data (that, with RDF represents the core technologies behind SOLID) rely on HTTP protocol features and standards, namely content negotiation and HTTP verbs (i.e. not only get but PUT, PATCH, DELETE, POST, etc). I’m interested to know more about this topic. Perhaps an IPFS solid implementation could introduce some limitations to the current solid specification (e.g. forcing a serialization type, for instance, turtle o json-ld for data representation)

#13

I think that SOLID on IPFS would be problematic. RDF can use HTTP but technically doesn’t rely on it. It does rely on URI’s, how you dereference them is another matter. (you can use mailto:, tel:, etc just find in RDF). Linked data, similarly, doesn’t require HTTP even thought that’s what everyone uses.

I think the problem is going to come with IPFS being content addressable and RDF not having a canonical representation. N-triples/n-quads will be the closest you’ll get but you’d still have a problem with anonymous nodes, aka blank nodes. There are things you can do to work with them but you’ll get into all kinds of crazyness with skolomization, graph isomorphism, blah, blah, blah.

I think you’d end up making heavy use of ipns and negating much of what you want from IPFS. That being said, I’m very interested in how you could use IPFS and RDF.

#14

Hummm… for what I can understand, you are right about RDF, but SOLID relies on HTTP. Blank nodes are just confined in resources (ie files) and cant’ be de-referenced, so they should not represent a problem. If IPFS supports all HTTP verbs, in principle it could be used to implement a sort of distributed, serverless SOLID pod. Applications need to implement a sort of RDF cache to collect data from different IPFS and making queries. Yes, you’d end up making heavy use of ipns but this should be easily cacheable.

#15

You let me know how that goes.