Here is the full text of the blog, which suffers from so many different problems at different stages that I have to just comment in line. It seems, firstly, just not to understand, or take into account the solid architecture, in particular the "client to client" standards which provide interoperability the Application level (level 7). It seems to have issue with the pod as being a set of graphs The only valid issue
Ruben Verborgh
30 December 2022
Let’s talk about pods
A new solution space for apps emerges if we adopt a better model for thinking about Solid.
Who writes, decides”. That is, the first app to sculpt documents and containers in your pod determines where other apps need to look for data.
No, that's not how Solid works. If the first app to write into your pod is one which has designed this data shape for the first time, and then it documents it as a spec which is then adopted by the community, then that is how it works, bt in general, no apps writing according to to stanbdards -- most of which still need to be written.
Unfortunately, this creates an undesired dependency between apps, which now have to agree amongst each other on how to store things. Yet Solid promises apps that will seamlessly and independently reuse data in order to provide us with better and safer experiences. At the heart of this contradiction is that the mental model we’re using for Solid pods no longer works. This model restricts our solution space and is a main reason why apps struggle to reuse each other’s data. In this blog post, I argue why we should stop thinking of a pod as a set of documents,
The Pod, in RDF terms, is a quadstore, not a triple store. A triples store is not powerful enough. The 4th part of the quad, the ID of the graph, we call a 'Document' to make it match with the way people talk. They might be called Named Graphs or Linked Data Resources but "Documents" is simpler. The fact that the ;inked data in a pod is basically a set of distinct graphs is really important. (This is one of the four things you attack. The others are the structure of documents in folders, and the lack of triple-level access control).
and start treating it as the hybrid graph it actually is.
(my bold). Ouch. It is one thing to propose a a model which is congruent and equivalent to the existing model, but when they are actually different to then suggest that only your one the one true model is much more destructive.
But talking about a pod as a hybrid graph is useful, if hybrid graph has the metadata about each document at the top level and within it nested blobs of binary like PNG files, and also nested separate graphs of the linked data of each of the data documents, and possibly further nested graphs within N3 documents.
By adjusting our perspective, Solid apps can become more independent of variations in data—and thus more powerful for us.
For several centuries, it appeared self-evident to many that the sun and planets revolved around the earth. Supported by our intuitive notions of sunrise and sunset, basic mathematical theories for this geocentric model could adequately explain and predict planetary movements. But over time, we started observing strange movements that the model couldn’t readily explain: in an apparent retrograde motion, Mars was sometimes seen flying backwards before returning to a more sensible
forward path.
When observations contradict your model, there are essentially two things you can do. Either you make the model more complex to account for those observations, or you switch to a new model that can fit them in. Hence, a first group of people attempted to explain Mars’ unusual orbit by adding epicycles to the geocentric model, letting celestial bodies wriggle around in additional circles. A second group abandoned geocentrism altogether, with proponents such as Copernicus and Galilei supporting a heliocentric model that explained the same motions better with far less trickery—by placing the sun in the center. Not only does Occam’s razor favor this simpler theory; heliocentrism was the model that could explain all observations and enable accurate predictions.
A new model does not magically make problems disappear, as many questions about the universe remain unanswered today. But the right model gives us the correct frame of reference to reason about our universe, and to devise new solutions for existing and new problems. Further corrections to the heliocentric model were indeed needed: planets follow an ellipse rather than a circle, and the moon doesn’t orbit the earth but they both orbit a common barycenter. Yet the framework within which those solutions were discovered was essential to their discovery.
Our models of reality determine the shape of our solution space.
In this blog post, I want to challenge the prevalent model we’ve used so far to think about Solid pods.
Philosophically, this is a bogus analogy: You say that Solid's model of reality is wrong - but Solid is not a model of reality. It is a new architecture, a new type of designed space. Solid, if you like, defines a new space with properties we chose. You can't fault Solid for being a bad model of realty. It is Philosophical Engineering, not Physics.
My research team demonstrated that some very common cases cannot be addressed by the current document-centric model. Even worse, we found that—no matter how creative or sophisticated your solution — holding on to the single document hierarchy means that any Solid app you develop will always be bound by certain key limitations. I will explain what those limitations are and how we can more easily solve data challenges within Solid by adopting a different model.
The article is confused whether it it is criticizing the fact that data is stored in documents, or the fact those documents are in a hierarchy of containers.
Keeping data and apps separated
Here’s the most common question I get asked by people who build Solid use cases:
Where in a pod should I store [this particular piece of] data?
This question might seem peculiar, since they know their use case best, so why are they asking me how to store their data? To find a satisfying answer, we must understand the deeper question that implicitly underlies this particular problem.
The technological promise of Solid is the separation of data from apps.
Yes, this is done with the solid standards - the client-server Solid Protocol and the client-client standards. The article's core fault is that it completely ignores the client-client standards.
We want to reuse data in any app where it makes sense, regardless of which app first captured that data. This independence unlocks the unprecedented creativity and innovation
that Solid is all about: apps don’t need to collect your data (again) before they can make your data work for you. And the way to make our data work, is to make it seamlessly interoperable with different apps.
Indeed. Thus interop comes from standards.
Therefore, the question of where to store data is not about making one app work—it’s about how to make that data work for all other apps. In traditional client–server development, a developer’s task is to make apps run against a specific backend.
Well, currently some non-Solid systems make their own Restful APIS but other, like Contacts and Calendars, use standards like CardDav and CalDAV.
In contrast, today’s Solid developers feel a responsibility for the entire ecosystem, as any decision they make affects other apps. So the question they’re really asking is:
How does the way we write data impact others’ ability to reuse that data?
And that, of course, is a much more complex matter, because we can’t predict how other apps in the future might want to reuse the data we write today.
Except you can, because we develop publish standards.
Solid is not about making data flow better for one app, but for all current and future apps.
The fact that one app’s decision on how to store data potentially affects all other apps, is a tell-tale sign that data and apps are not really separated yet in today’s Solid landscape.
That is nonsense. The data and the apps are separated - the data goes in the pod. The server which runs the pod does not care what app the users runs. The apps use client-client standards so you can pick whichever app you like at any time to work with the same data.
Because apparently, there is some meaning, some kind of semantics in the location an app chooses to write our data, and that understanding is not shared between different apps.
Here the author is confused maybe about a couple of things. In the general the URIs we use for things often end up having words in them like "Profile" or "Public" or "Settings" to make life easier for users and developers. But there is no semantics in those bits of URI. The access allowed is set in the Solid ACL system, and it is that which determines which bits of a pod are public. If a folder is called "Contacts" that is useful nmonic ut is NOT any semantics. but the software tracks that it follows linked from a person't identity through their pod to find things which are of class AddressBook. To in that sense there is no semantics of the locatuon.
In another sense, though there is semantics to the location as the location affects what access who has to it -- and hence, what it is trusted for. I share with my sports coach (say) my medical test results in a folder which can only be written by the medical facilities I use. I don't share it with anything or anyone else. So if a developer ass you next time where to store some data, could questions include, "Where is it coming from (what is its provenance?) and where is it going to (what is its destiny?). Because the Access Control systems work around the folder systems, things with similar provenance and desiny it is useful to keep together. But also of course things whch are part of the same project, same activity, same activity, same interaction, and so on.
This seriously hinders interoperability and serendipitous reuse, which I consider absolutely vital to a thriving personal data ecosystem.
As we’ll discuss next, one approach aims to address issues within the current pod model by making those semantics explicit in a contract.
You mean a client-client standard? Yup that would be good.
However, we’ll argue that, no matter what we try, this model will always break because it insufficiently reflects reality.
This may be the crux of the falacious argument. The author looks at the existing state of the solid universe in 2022, when the client-server standards are quite developed but the client-client standards very rudimentary, and assumes that that is the "reality" which must be modelled. It assumes that there will never be those sndards in place, rather tha help put them in place.
In practice on the Internet, standards are made by a mixture of processes.
That’s why we’ll discuss a new model, which is better equipped to tackle app interoperability.
A pod as a single document hierarchy
The desirable simplicity of documents
Our mental model for a Solid pod today is a single hierarchical collection of documents. That makes sense, because documents are a common abstraction for human–computer interaction: our own computers offer document-based filesystems, and so do familiar platforms such as Dropbox and Google Drive. And of course, the Web itself started off as a document system on
the Internet.
It therefore comes as no surprise that the smallest unit of organization in current Solid pods is a document.
This is bizarre augument as the Solid pod is not a model of some reality which can measured experimentally. It is an engineered system where these things (document model, folder structure, slash semantics) are expplicit design choices. They can be reconsidered - but as a complete alternative system.
These are organized recursively in containers, which can contain documents or other containers. Many documents are documents consisting of Linked Data, such that they can point to other documents inside this pod or other pods.
Importantly, each pod has exactly one document organization; it’s the main and only entry point to a pod. The entire pod is thus its document organization and the content of those documents.
For example, Helen’s pod might be a collection of documents that could look like this:
And Jennifer’s pod might be another collection of documents:
Note how Helen and Jennifer both have a Solid pod consisting of containers, documents with Linked Data, and non- documents—organized in their own ways.
The power of Solid is that these different collections of documents are exposed in a standardized way through the Solid Protocol. Therefore, a client uses the exact same steps to retrieve a document from Helen’s or Jennifer’s pod — just like a Web browser uses the same instructions ( ) to retrieve webpages from different websites.
The differences between how Helen and Jennifer organize documents in their own pods, highlight that not everything is standardized. Each Solid app has many degrees of freedom for writing data to pods, as the Solid specifications do not stipulate:
How is data modeled inside of a document?
How is data distributed across documents?
How are documents structured across containers (and pods)?
Not coincidentally, these aspects are exactly what developers address when they define a Web for their app, as servers and clients must agree on where and how things are stored. Consequently, the Solid Protocol is not a Web ! Rather, it allows and requires each individual app to decide where and how they store Linked Data. And the burden of this requirement is that this decision impacts every potential consumer of that data. And while non-Solid apps consider their Web a most important and visible contract, Solid apps tend to not document their Web at all.
■ ■ ■
Extending interoperability to the data level
This is a core challenge that any model for a pod should address: the authentication and authorization interoperability provided by the protocol must extend to the crucial data level on which Solid wants to achieve independence from apps. Neither the Solid Protocol nor the use of Linked Data are sufficient to achieve this required data-level interoperability. This is why Solid apps aren’t great yet at reusing others’ data, and hence why they can’t fulfill the Solid promise of data and app independence.
"Neither the Solid Protocol nor the use of Linked Data are sufficient" .. exactly... but then add the client-client Solid app-level standards, which this article completely ignores.
Basically, each Solid app is designing its own Web by creating documents and containers in a way that suits this application. In doing so, the app implicitly puts meaning in the document organization that is not captured anywhere else. This forces
Solid apps to resort to classical integration rather than data integration.
Of course, the simplicity of the document-centric pod is hard to resist. Therefore, several community proposals aim to make the unwritten contracts explicit by documenting a pod’s Web and its underlying semantics within dedicated documents in each pod. Core ideas include shapes to characterize data inside of documents, and descriptions of how to distribute data across documents.
These meta-stndard systems in which the data is not standard, but its descibed in a stndard way, are interesting but much more complex than stndard stsrems. This reqies rul-level inference from all partipating systems, which is not something we shpuld introduce at this stage.
Current proposals such as Type Indexes help clients find their way by linking to pod items, and the current Solid Application Interoperability draft points to the Shape Trees specification to describe, validate, and enforce the specific Web exposed by a pod. The aim of these proposals is allowing apps to share their data organization with each other while staying within the realm of documents, at the cost of increasingly complex structural descriptions that clients need to maintain faithfully. But even if we could trust all clients with all this bookkeeping—can it ever be enough?
The Type indexes spec is part of the solution at the high level. It allows a user to track large domain specific structures like Address Books, Photo Libraries, Medical Data Libraries, Calendars, Recipe Libraries, Music Libraries, and so on. It provides a simple index to start the disovery. Within each data library, further subindexes are very domain-specific -- music, for example is indexed by Artist, Track, Album, Genre, Recipes by ingregients, etc. This is desibed in @@@ref PodStuff.
The effect of this structure though, is to mean that the whole indirect indexing of the whole pod is tractable. You have to put in the same sort of effort existing desktop or web apps do to manage photos, fitness, etc, and then add aeach domain's data into the pod. Then the user has a lot of functionalty and the ability to share in all the various domains also within communities of various forms. (An interesting question is how to reguster the extra tools one app adds to a completely different app though the solid "anythimg can do anytiing with anything" mantra.)
One can’t rule them all
The contacts conundrum
No matter how clever or complex interoperability proposals become, we found that document-centric techniques will never be able to address several key scenarios. Current and future proposals share the limitation that the single document-centric is an insufficient model to represent the complexity of many real-world use cases. Solutions within this model will always be bound by its flaws, and they will encounter problems they can’t solve because their solution space is restricted to that
same model.
I’ll demonstrate the issue with a very simple example that the document-centric model can’t account for. The idea is that, if
even this toy example manages to break the model, then more complex use cases will definitely break it.
Let’s assume Helen wants to store contacts in her pod: her family, friends, co-workers, staff members, ... . There are dozens of ways of organizing these contacts across multiple documents in a pod. Fortunately, she doesn’t need to directly edit those documents, because she chooses Solid apps that do this for her:
She uses an address book app to browse her contacts one by one, to edit people’s details, and to add new contacts. Thanks to the birthday app, she gets a timely reminder when significant events are coming up.
For example, the address book app might store Helen’s contacts like this:
■ ■
But the birthday app might store Helen’s contacts like this:
Now of course, if those two apps organize things differently, how will they reuse each other’s data? The core idea of Solid is that data and apps are independent, thus that data should flow freely between apps. And neither structure is necessarily more appropriate or obvious than the other: structuring contacts in documents makes as much sense as structuring events in documents. Each view of the world makes perfect sense; they’re just different reflections of the same reality.
Can we tell those apps which structure was chosen for a given pod, by making the pod’s Web structure explicit? We could create agreements for certain topical domains. Or we could set up Type Indexes to point apps to the contacts, or Shape Trees to describe which of both organizations (or perhaps yet another) Helen has chosen. Unfortunately, that won’t help either app, as their expectations differ too much.
Any solution within the document-centric pod model cannot organize data at a more granular level than documents, because documents are the smallest organizational unit. And even with our trivial contacts example, our two apps have conflicting requirements:
If we choose the address book that creates one document per contact:
The birthday app can access data it’s not supposed to (address, phone number, ...).
Helen cannot share her birthday list within her friend group, because she’d be sharing everyone’s full details.
If we choose the birthday that stores multiple birthdays in one document:
The contacts app would have to mix the details of different contacts in one single document, which would get messy.
■
■
■
■
■
■
Helen would not be able to share individual contact details with her colleagues.
We can imagine workarounds, but none could fully achieve what we want. Copying data means that apps are not really reusing so they will get out of sync. And setting up synchronization processes leads to all kinds of corner cases. For instance, we could create a virtual document on top of the address book that aggregates birthdays from across documents. But that creates
a problem when Helen wants to add new contacts via the birthday app, because it cannot just write into the aggregated document view. And things get progressively worse when Helen also wants to store birthdays of people’s partners and children, because where would they be stored?
And recall that contacts were supposed to be the easy example! What if we want to store highly sensitive data, such as medical or financial records? Clearly, you should be able to track your heart rate with an app without it having access to your glucose or hormone levels. Why can’t the current pod model allow for this?
The perfect document box doesn’t exist
These and other problems inevitably occur because the single document organization is flawed in at least two major ways: