Re: WebID default serialization for WebID 2.x -- Live Demo

On 1/26/22 12:37 PM, Kingsley Idehen wrote:
> On 1/26/22 10:03 AM, Kingsley Idehen wrote:
>> On 1/25/22 9:09 PM, Nathan Rixham wrote:
>>> On Tue, Jan 25, 2022 at 11:59 PM Kingsley Idehen 
>>> <kidehen@openlinksw.com> wrote:
>>>
>>>     On 1/25/22 6:08 PM, Nathan Rixham wrote:
>>>>     On Tue, Jan 25, 2022 at 10:58 PM Kingsley Idehen
>>>>     <kidehen@openlinksw.com> wrote:
>>>>
>>>>         On 1/25/22 4:29 PM, Nathan Rixham wrote:
>>>>>         On Tue, Jan 25, 2022 at 9:23 PM Kingsley Idehen
>>>>>         <kidehen@openlinksw.com> wrote:
>>>>>
>>>>>             On 1/25/22 1:28 PM, Nathan Rixham wrote:
>>>>>>             Would a fair definition of a valid WebId then be
>>>>>>             something like: A URI is a valid WebIdentifier if it
>>>>>>             dereferences to a valid WebId-Profile describing the
>>>>>>             URI with the minimum set of required properties
>>>>>>             (type, name, public_keys)?
>>>>>
>>>>>             A WebID is a resolvable identifier that denotes an
>>>>>             agent. It resolves to a WebID Profile Document.
>>>>>
>>>>>          How do you know it's a WebID before you resolve it?
>>>>
>>>>         Good question!
>>>>
>>>>         By deciding the want to denote yourself using a given
>>>>         identifier, relative to your profile document.
>>>>
>>>>     Let me rephrase, and suggest looking at it the other way
>>>>     around: given a random IRI <y> how do I know <y> is a webid /
>>>>     refers to an Agent, without first resolving it? and as a sub
>>>>     point, is a "valid" webid?
>>>
>>>     You know it is a WebID because the spec says its is a URI that
>>>     denotes an Agent. That's it, really :)
>>>
>>>     "
>>>
>>>     WebID
>>>         A WebID is a URI with an HTTP or HTTPS scheme which denotes
>>>         an Agent (Person, Organization, Group, Device, etc.). For
>>>         WebIDs with fragment identifiers (e.g. #me), the URI without
>>>         the fragment denotesthe Profile Document.
>>>
>>>     "
>>>
>>> I feel something is getting lost in translation.
>>>
>>> There's no way to know this without doing something first, to 
>>> implement anything in code it would need to be the opposite way 
>>> around, "A URI is a WebID if...", there's no way for a system to 
>>> know it's a WebID without further information, and the spec should 
>>> define what that information is, and how to get it, the minimum 
>>> needed to determine that a previously unknown uri <y> as a WebID via 
>>> some mechanism.
>>>
>>> "A WebID is a URI with.." doesn't actually help or provide any 
>>> guidance or useful definition, indeed it's entirely impossible to 
>>> get any further unless you know beforehand that `<y> an :Agent`, but 
>>> you don't know this until after you've tried to resolve <y> ..
>>>
>>> Am I making sense here?
>>>
>>
>> Long story short, I hope:
>>
>> Entity description journeys start from description documents. 
>> Basically, as you craft your entity description in a document its 
>> identity would either be known or constructed inline, relatively.
>>
>> I provided an example that demonstrates the point above.
>>
>> Here are the steps:
>>
>> 1. Open a file
>>
>> 2. Start making notes that describe the entity being profiled
>>
>> 3. Save document
>>
>> 4. Publish to the Web
>>
>> If you don't have an existing identifier to hand for any entity in 
>> your doc, use a relative identifier.
>>
>> Working the other way around with an identifier an not document isn't 
>> how this is supposed to work, really.
>>
>> Examples of WebIDs or NetIDs that past the basic test re entity 
>> denotation.
>>
>> 1. https://twitter.com/kidehen#this
>>
>> 2. https://linkedin.com/in/kidehen#this
>>
>> Examples of NetID-Profile docs, since they don't resolve to either 
>> JSON-LD or RDF-Turtle docs:
>>
>> 1. https://twitter.com/kidehen
>>
>> 2. https://linkedin.com/in/kidehen
>>
>> If I am writing a profile doc about myself I can extend my earlier 
>> example as follows:
>>
>> ## Turtle Start ##
>>
>> @prefix schema: <http://schema.org/> .
>> @prefix foaf: <http://xmlns.com/foaf/0.1/> .
>> @prefix dcterms: <http://purl.org/dc/terms/> .
>> @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
>> @prefix like: <http://ontologi.es/like#> .
>> @prefix twitter: <https://twitter.com/kidehen#> .
>> @prefix linkedIn: <https://linkedin.com/in/kidehen#>.
>> @prefix : <#> .
>>
>> ## About Profile Doc
>>
>> :doc
>> a schema:WebPage;
>> schema:title "A Personal Profile Document"@en ;
>> schema:mainEntity :netid .
>>
>> ## About Me
>>
>> :netid
>> a schema:Person ;
>> schema:name "Kingsley Uyi Idehen"@en ;
>> schema:description "A document about me"@en ;
>> owl:sameAs linkedin:netid, twitter:netid ;
>> schema:mainEntityOfpage :doc .
>>
>> ## Turtle End ##
>>
>> Fundamental point:
>>
>> We are looking the user journey differently.
>>
>> My approach is informed by the file create, save, and share pattern 
>> that actually triggered the Web explosion via HTML.
>>
> Little correction, after looking at this post via a browser that 
> includes our Structured Data Sniffer (OSDS) extension:
>
> ## Turtle Start ##
>
> @prefix schema: <http://schema.org/> .
> @prefix foaf: <http://xmlns.com/foaf/0.1/> .
> @prefix dcterms: <http://purl.org/dc/terms/> .
> @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
> @prefix like: <http://ontologi.es/like#> .
> @prefix twitter: <https://twitter.com/kidehen#> .
> @prefix linkedIn: <https://linkedin.com/in/kidehen#>.
> @prefix : <#> .
>
> ## About Profile Doc
>
> :doc
> a schema:WebPage;
> schema:title "A Personal Profile Document"@en ;
> schema:mainEntity :netid .
>
> ## About Me
>
> :netid
> a schema:Person ;
> schema:name "Kingsley Uyi Idehen"@en ;
> schema:description "A document about me"@en ;
> owl:sameAs linkedIn:netid,twitter:netid  ; # changed linkedin:netid to linkedIn:netid
> schema:mainEntityOfpage :doc .
>
> ## Turtle End ##


I've written a Twitter Thread to demonstrate the one I've been making, 
for quite some time [1]. Basically, a mailing list post can even 
function as a WebID-Profile document -- courtesy of relative HTTP URIs 
for WebID construction.

Everything starts with a document and a host operating environment that 
supports pointers (HTTP URIs) and addresses (HTTP URLs).

Our computers run on operating systems equipped with this functionality, 
which is why can create documents and programs that operate on document 
content. The Web was designed to lift this native capability into the 
Internet by way of deft abstraction.


Links:

[1] https://twitter.com/kidehen/status/1486396372249202701 -- Twitter 
Thread demonstrating my point about WebIDs

-- 
Regards,

Kingsley Idehen 
Founder & CEO
OpenLink Software
Home Page:http://www.openlinksw.com
Community Support:https://community.openlinksw.com
Weblogs (Blogs):
Company Blog:https://medium.com/openlink-software-blog
Virtuoso Blog:https://medium.com/virtuoso-blog
Data Access Drivers Blog:https://medium.com/openlink-odbc-jdbc-ado-net-data-access-drivers

Personal Weblogs (Blogs):
Medium Blog:https://medium.com/@kidehen
Legacy Blogs:http://www.openlinksw.com/blog/~kidehen/
               http://kidehen.blogspot.com

Profile Pages:
Pinterest:https://www.pinterest.com/kidehen/
Quora:https://www.quora.com/profile/Kingsley-Uyi-Idehen
Twitter:https://twitter.com/kidehen
Google+:https://plus.google.com/+KingsleyIdehen/about
LinkedIn:http://www.linkedin.com/in/kidehen

Web Identities (WebID):
Personal:http://kingsley.idehen.net/public_home/kidehen/profile.ttl#i
         :http://id.myopenlink.net/DAV/home/KingsleyUyiIdehen/Public/kingsley.ttl#this