Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Oct 15 21:51

    csarven on main

    Minor (compare)

  • Oct 15 15:19
    kjetilk milestoned #321
  • Oct 15 15:19
    kjetilk labeled #321
  • Oct 15 15:19
    kjetilk labeled #321
  • Oct 15 15:17
    kjetilk synchronize #321
  • Oct 15 15:17

    kjetilk on sparql-update-simplify

    Add overview section, link Yack… (compare)

  • Oct 15 15:12
    kjetilk commented #125
  • Oct 15 15:02
    RubenVerborgh commented #125
  • Oct 15 14:26
    kjetilk commented #125
  • Oct 15 14:13
    kjetilk commented #321
  • Oct 15 14:01
    kjetilk commented #125
  • Oct 15 12:56
    kjetilk commented #320
  • Oct 15 12:51
    kjetilk milestoned #324
  • Oct 15 12:51
    kjetilk labeled #324
  • Oct 15 12:51
    kjetilk labeled #324
  • Oct 15 12:50
    kjetilk assigned #324
  • Oct 15 12:50
    kjetilk review_requested #324
  • Oct 15 12:50
    kjetilk review_requested #324
  • Oct 15 12:50
    kjetilk opened #324
  • Oct 15 12:48

    kjetilk on sparql-update-semaphore

    Add possible semaphore mechanis… (compare)

Fred Gibson
@gibsonf1
solid:User would be nice to have
I guess I'm basically trying to complete this triple: solid:account rdfs:domain ?x
the range is easy solid:Account
Sarven Capadisli
@csarven
<WebID>
an Agent
Fred Gibson
@gibsonf1
My understanding from tbl is that the webid is actually a url string, so you wouldn't say that the user is a type of WebId with properties like having storage
Tim Berners-Lee
@timbl
Yes, the webids of people are stored in vCard as vCard :url with type vCard:WebId
Tim Berners-Lee
@timbl
We have a problem that we have dropped solud discovery it seems. It is the first client-client spec so in a wag the most urgent after the solid protocol. We have chat apps and contacts stuff which uses the type indexes to find chats and address books etc through the type indexes and that spec is small but important.
It should be presented to the VC folks and linked from the ecosystem.
Sarven Capadisli
@csarven
@gibsonf1 I obviously didn't mean <WebID> as a Class... and wrote "an Agent" to hint at the class.. a person, an org.. a software agent.. as the definition of solid:account says "A solid account belonging to an Agent." .. so, yes, foaf:Agent, schema:SoftwareAgent, vCard:WebId fits.
Henry Story
@bblfish

:point_up: January 4, 2021 9:43 PM
@csarven wrote:

Zero: Stop thinking in terms of LDP

Btw. I think one should not stop thinking it terms of LDP, rather think in terms of refinements of LDP. There's a lot of work that went into LDP (5 years with major players, a test suite and a spec) and we should not dismiss that work.

Pete Edwards
@edwardsph
WAC question: from the spec (albeit a draft version) is seems to me that the acl:default predicate is only applicable in a container ACL and its target can only be a container. Is that correct? Does it have meaning in a non-container resource's ACL and is it an error or just redundant if found there?
Sarven Capadisli
@csarven
@timbl Not dropped. Perhaps didn't get the original documentation/spec into PR. Can follow up.
@bblfish Not sure I'd call it refinement because we're not merely extending LDP. That was never the case. Original understanding perhaps required LDP but that was never really the case.. not even the implementations actually conformed to LDP. I'm all for alignment as much as possible but I don't think we need to be boxed by it either.
Henry Story
@bblfish
Trellis explicitly implements LDP.
I worked on LDP, I know what is going on. And many people do.
Perhaps you could write up a document as to where Solid diverges rather than complements LDP, so we could understand why and where to be careful.
Sarven Capadisli
@csarven
@edwardsph range is Container.. I think I wrote a bit of that here https://github.com/solid/specification/issues/193#issuecomment-679012925 ... but let me come back to this.. need to re-read/confirm..
Pete Edwards
@edwardsph
@sarven I guessed that would be the range but it is not defined in the schema at https://www.w3.org/ns/auth/acl. Probably a simple omission. The issue you referenced is helpful.
Henry Story
@bblfish

@csarven wrote:

@bblfish Sure https://gitter.im/solid/specification?at=5ff399e18bb734746973c257

Those points by @acoburn show Solid be an extension of LDP. (And one of those points I would say needs to be very carefully phrased as it could be problematic.)

Sarven Capadisli
@csarven
@edwardsph Ignore the bit on delete at the bottom of that comment I linked to..
elf Pavlik
@elf-pavlik

We have a problem that we have dropped solud discovery it seems. It is the first client-client spec so in a wag the most urgent after the solid protocol. We have chat apps and contacts stuff which uses the type indexes to find chats and address books etc through the type indexes and that spec is small but important.

discovery is included in draft from interoperability panel, especially:

both aim to take into account access control in process of data discovery

big batch of updates is coming in solid/data-interoperability-panel#71 (you can see rendered preview)
Sarven Capadisli
@csarven
@elf-pavlik That's not what Tim is talking about.
elf Pavlik
@elf-pavlik

We have chat apps and contacts stuff which uses the type indexes to find chats and address books etc through the type indexes

I thought it refers to https://github.com/solid/solid/blob/master/proposals/data-discovery.md#type-index-registry

Sarven Capadisli
@csarven
Your response doesn't.
elf Pavlik
@elf-pavlik
Applications can discover kinds of data they are authorized to access (chats projects, etc.) using data registrations. I think that covers requirements that type indexes were trying to address.
2 replies
Sarven Capadisli
@csarven
If I'm not mistaken, Tim is concerned that we don't have data-discovery.md in the spec (yet).. considering we have some public implementations of it.
elf Pavlik
@elf-pavlik
I recall Michiel de Jong proposing to just copy over old draft and iterating on that, but I thought we decided not do do it this way. I pointed relevant working in Interoperability Panel since to my understanding it will cover same requirements without the limitations of type indexes from the old draft.
maybe @justinwb has some input on how Data Registration relates to Type Indexes
justinwb @justinwb just getting back on - reading back through the thread
Justin Bingham
@justinwb
Okay so first and foremost, the two are not mutually exclusive, so I want to make sure we avoid looking at one scheme as competing with, or replacing the other.
The discovery approach documented at https://github.com/solid/solid/blob/master/proposals/data-discovery.md that leverages type indexes has one responsibility - it "provides a way for a client application to discover where a user keeps data relevant to this app". It is designed to (primitively) query for and find types of data an app needs.
The pertinent segment of the application interoperability specification is Data Registration. A data registry is a place to store your data, organized by type. The purpose of that organization is principally for validation, to ensure the data is enforceably well-formed, and to provide reliable and consistent authorization boundaries.
Justin Bingham
@justinwb

From the description of a Data Registry:

A Data Registry can be used for basic discovery, but it is not designed nor intended to be an efficient means to query or index data. However, it is intended to be used as reliable source data for different query engines or indexing schemes.

Supporting (rather than conflicting with) different query patterns has been the intention from the start.
19 replies
Put in other words - yes this is linked data, so you can follow your nose from the identity document if you have permission, but really you should pair this with an efficient query/index scheme. Again - complementary.
When dealing with data that is publicly accessible, they can work together right now. With private data, which accounts for a large majority of use cases in personal data stores, there is no functional limitation, but the privacy story gets a bit more complicated.
Justin Bingham
@justinwb
I think its safe to say that most of us believe in a world where we're storing a broad spectrum of our personal data in a Solid pod, or we wouldn’t be here. That means that some of this data is going to be extremely personal and sensitive.
To realize the dream, we have to be able to demonstrate that data is safely compartmentalized. When I give a person or an application access to X, they only have access to X, and they only know about X. They don't know anything about Y or Z. When I use an Application to help me manage my finances, it shouldn't be able to know anything about my medical history. When I use an application to play chess, it shouldn't be able to know about my finances. This is a well established security axiom known as the principle of least privilege
Justin Bingham
@justinwb
PoLP is a guiding principle of the the Application Interoperability spec design. Data is fully compartmentalized, and ensuring information isn’t leaked through indexes is just as important as not leaking the data itself.
For example - the private type index as documented would allow any application i use to scan all registered data types, so that it can find what it's looking for. This means that any piloted application will have full visibility to every registered type of data stored in the pod, regardless of whether or not it can access that resource. If I have "Prescription" as a registered type, my Photo Manager knows that I'm medicated, even if it can’t access the resource.
Justin Bingham
@justinwb
Consequently, for private data, while a private type index approach can work functionally right now with the application interoperability specification, it wouldn’t preserve the integrity of the data compartmentalization that we worked so hard to maintain.
Given these considerations, the discovery pattern for private data is handled differently in the app interop spec. The application or agent expresses the kind of data that it needs access to, and then are told what access they have been given based on a conscious decision by the controller.
Justin Bingham
@justinwb
So - circling back to the beginning… While the pure nature of how the data is organized in the interop spec can provide basic discovery as a simple function of how it is structured - it is ultimately meant to be paired with an indexing scheme to be performant and responsive. Many indexing schemes (including type indexes) are suitable and complementary. Some indexing schemes introduce privacy implications that we have to be very cognizant of.
Henry Story
@bblfish
Hi @mwherman2000, re your comment on issue Self-Sovereign Identity Model Principles: Identifier and Identity Data Usage Licensing. You dropped in some very large high resolution pictures in there, which is great for those with glasses, but it also takes up a lot of real estate, making the flow of the ideas a bit difficult to follow. Some pictures are clearly much larger than they need to be, such as the phone screenshots.
I think you can get the best of both worlds by wrapping the images with an <img src="..." height="100" width="..."> code. This is part of the github raw html extensions capability. It does not actually give an example with img size. But I found an issue jgm/pandoc#2554 and I have tried it previously on some other markdown pages of github.
1 reply
Aaron Coburn
@acoburn
@bblfish FYI, trellis intentionally ignores certain parts of LDP. One example is that CORS conflicts with LDP's requirements for OPTIONS requests. There is a lot of good stuff in LDP, but by requiring it for Solid, you end up inheriting the mistakes, too. Plus, there is a compelling argument to be made that it should be possible to build a Solid server on top of platforms that dont attempt to implement LDP at all
Henry Story
@bblfish
Understood. Still, I think it would be good to have a wiki or set of "LDP-divergence" tagged issues where these problems are listed. It would help people like me with an LDP background to understand what is going on, allow us to provide feedback to the ldp community, and perhaps recognize that some of those are not really problems but just extensions, or perhaps even mistakes on the Solid side. (I don't know)
Henry Story
@bblfish
That would be very useful when running the LDP test suite for example.
Eric Prud'hommeaux
@ericprud
@acoburn , if you have specific erata for LDP, we can stick them in the errata document
Henry Story
@bblfish
perhaps worth opening an issue before popping them in there. I'd be happy to review those.