Re: Microsoft Access for RDF?
Hi Kingsley, In https://lists.w3.org/Archives/Public/public-lod/2015Feb/0116.html You said, re Annalist: My enhancement requests would be that you consider supporting of at least one of the following, in regards to storage I/O: 1. LDP 2. WebDAV 3. SPARQL Graph Protocol 4. SPARQL 1.1 Insert, Update, Delete. As for Access Controls on the target storage destinations, don't worry about that in the RDF editor itself, leave that to the storage provider [1] that supports any combination of the protocols above. Thanks for you comments and feedback - I've taken note of them. My original (and current) plan is to provide HTTP access (GET/PUT/POST/etc) with a little bit of WebDAV to handle directory content enumeration., which I think is consistent with your suggestion (cf. [1]). The other options you mention are not ruled out. You say I shouldn't worry too much about access control, but leave that to the back-end store. If by this you mean *just* access control, then that makes sense to me. A challenge I face is to understand what authentication tokens are widely supported by existing HTTP stores. Annalist itself uses OpenID Connect (ala Google+, etc) is its main authentication mechanism, so I cannot assume that I have access to original user credentials to construct arbitrary security tokens. I had been thinking that something based on OAuth2 might be appropriate (I looked at UMA [2], had some problems with it as a total solution, but I might be able to use some of its elements). I took a look at the link you provided, but there seem to be a lot of moving parts and couldn't really figure out what you were describing there. Thanks! #g -- [1] https://github.com/gklyne/annalist/issues/32 [2] http://en.wikipedia.org/wiki/User-Managed_Access, http://kantarainitiative.org/confluence/display/uma/Home
Re: Microsoft Access for RDF?
On 2/24/15 6:07 AM, Graham Klyne wrote: Hi Kingsley, In https://lists.w3.org/Archives/Public/public-lod/2015Feb/0116.html You said, re Annalist: My enhancement requests would be that you consider supporting of at least one of the following, in regards to storage I/O: 1. LDP 2. WebDAV 3. SPARQL Graph Protocol 4. SPARQL 1.1 Insert, Update, Delete. As for Access Controls on the target storage destinations, don't worry about that in the RDF editor itself, leave that to the storage provider [1] that supports any combination of the protocols above. Thanks for you comments and feedback - I've taken note of them. My original (and current) plan is to provide HTTP access (GET/PUT/POST/etc) with a little bit of WebDAV to handle directory content enumeration., which I think is consistent with your suggestion (cf. [1]). Yes. The other options you mention are not ruled out. Okay. You say I shouldn't worry too much about access control, but leave that to the back-end store. If by this you mean *just* access control, then that makes sense to me. Read and Write modalities scoped to an identity principal. A challenge I face is to understand what authentication tokens are widely supported by existing HTTP stores. Most will support digest authentication. For more sophisticated solutions you should consider WebID-TLS [1] and WebACL [2] which simply boils down to servers determining identity principals and resource privileges via relations in a WebID-Profile [3] document and a server's WebACL doc. You can also bolt OAuth on to WebDAV, as we have, but it may be a lot of work. BTW -- we do have a generic Authentication Layer in Virtuoso that supports Digest Authentication, WebID-TLS, basic PKIX+TLS, OpenID, and OAuth. We are even planning to decouple the aforementioned module from Virtuoso via a Javascript library that will be released in Open Source form to Github. Only hold-up is prioritization, so I can provide a firm ETA. Annalist itself uses OpenID Connect (ala Google+, etc) is its main authentication mechanism, so I cannot assume that I have access to original user credentials to construct arbitrary security tokens. I had been thinking that something based on OAuth2 might be appropriate (I looked at UMA [2], had some problems with it as a total solution, but I might be able to use some of its elements). See comment above. I took a look at the link you provided, but there seem to be a lot of moving parts and couldn't really figure out what you were describing there. It looks like that on the surface, but it simply boils down to: 1. Javascript 2. Ajar (Asynchronous JavaScript and RDF) -- TimBL tried to kick of this Ajar meme a few years ago with limited uptake, but its darn neat!) 3. Terms for making Identity Claims from a Certificate Vocabulary 4. A Storage relation described by a Personal Information (PIM) Vocabulary 5. WebID-Profile document that includes relations based on terms from the PIM and Certificate vocabularies. I re-read my original post [4], and realized its could be clearer, so I've tweaked it a little. Thanks for bringing the many moving parts perception to my attention. Links: [1] http://www.w3.org/2005/Incubator/webid/spec/tls -- WebID-TLS protocol [2] http://linkeddata.uriburner.com/c/9D3D4FSF -- a Web Access Control Vocabulary [3] http://www.w3.org/2005/Incubator/webid/spec/identity/#webid-profile-vocabulary -- WebID Profile Document [4] http://kidehen.blogspot.com/2014/07/loosely-coupled-read-write-interactions.html -- slightly revised edition. Kingsley Thanks! #g -- [1] https://github.com/gklyne/annalist/issues/32 [2] http://en.wikipedia.org/wiki/User-Managed_Access, http://kantarainitiative.org/confluence/display/uma/Home -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: AJAR (WAS: Microsoft Access for RDF?)
On 2/24/15 12:20 PM, Paul Tyson wrote:
On Tue, 2015-02-24 at 11:43 -0500, Kingsley Idehen wrote:
It looks like that on the surface, but it simply boils down to:
1. Javascript
2. Ajar (Asynchronous JavaScript and RDF) -- TimBL tried to kick of this
Ajar meme a few years ago with limited uptake, but its darn neat!)
Kingsley, do you have further references for AJAR? It sounds like the
approach I stumbled onto while looking for a sensible way to make a
heavy client for displaying RDF. In theory it could provide great power
and simplicity, but I can't say I've worked through the initial
complexity to prove the point.
Regards,
--Paul
Quick description of an old TimBL post related to Ajar, using nanotation
(which turns this post into an RDF data source) [1]:
{
a schema:WebPage ;
rdfs:label Description of Ajar related items ;
rdfs:comment Describes Ajar concept and a related Blog Posting.
;
dcterms:created 2015-02-24T13:47:00-05:00^^xsd:dateTime ;
foaf:maker http://kingsley.idehen.net/dataspace/person/kidehen#this ;
xhv:license http://creativecommons.org/licenses/by/4.0/deed.en_US ;
cc:attributionName Kingsley Uyi Idehen ;
schema:about http://dig.csail.mit.edu/breadcrumbs/node/62/,
https://twitter.com/hashtag/Ajar#this .
http://dig.csail.mit.edu/breadcrumbs/node/62/
a schema:BlogPosting ;
schema:about https://twitter.com/hashtag/Ajar#this ;
rdfs:label Links on the Semantic Web ;
foaf:maker http://www.w3.org/People/Berners-Lee/card#i ;
dcterms:created 2005-12-30T15:04:00-05:00^^xsd:dateTime ;
rdfs:comment On the Semantic Web, links are also critical. Here,
the local name, and the URI formed using the hash,
refer to arbitrary things. When a semantic web
document gives information about something, and uses a
URI formed from the name of a different document,
like foo.rdf#bar, then that's an invitation to look
up the document, if you want more information
about. I'd like people to use them more, and I think we
need to develop algorithms which for deciding when
to follow Semantic Web links as a function of what
we are looking for. -- TimBL
;
rdfs:comment
To play with semantic web links, I made a toy
semantic web browser, Tabulator. Toy, because it is hacked up in
Javascript (a change from my usual Python) to
experiment with these ideas. It is AJAR - Asynchronous Javascript
and RDF. I started off with Jim Ley's RDF Parser
and added a little data store. The store understands the mimimal
OWL ([inverse] functional properties, sameAs) to
smush nodes representing the same thing together, so it doesn't
matter if people use many different URIs for the
same thing, which of course they can. It has a simple index and
supports simple query. The API is more or less the
one which cwm and had been tending toward in python.
-- TimBL
;
schema:url http://dig.csail.mit.edu/breadcrumbs/node/62 ;
sioc:links_to http://dig.csail.mit.edu/breadcrumbs/taxonomy/term/17/,
http://dig.csail.mit.edu/breadcrumbs/taxonomy/term/20/,
http://dig.csail.mit.edu/breadcrumbs/taxonomy/term/1/ ;
rdfs:seeAlso http://dig.csail.mit.edu/2005/ajar/ajaw/Developer.html ;
opl:mentions https://twitter.com/hashtage/Ajar#this .
https://twitter.com/hashtag/Ajar#this
a skos:Concept ;
rdfs:label Ajar ;
skos:prefLabel Asynchronous Javascript and RDF ;
is schema:about of
http://dig.csail.mit.edu/2005/ajar/ajaw/Developer.html,
http://dig.csail.mit.edu/breadcrumbs/node/62/;
rdfs:comment Leveraging abstraction nature of RDF Language in
conjunction with XMLHttpRequest where format-specific is replaced with
RDF [which isserializable using a
variety of serialization formats]. XMLHttpRequest isn't actually XML
specific.;
xhv:related http://www.w3schools.com/json/json_http.asp .
}
Hope that helps.
[1] http://kidehen.blogspot.com/2014/07/nanotation.html -- Nanotation
(which enables the embedding of RDF statements, using TURTLE notation,
wherever plain text input is allowed)
[2] http://kingsley.idehen.net/c/D5MTTC -- processed version of
nantotions above (from a document saved to my Briefcase).
--
Regards,
Kingsley Idehen
Founder CEO
OpenLink Software
Company Web: http://www.openlinksw.com
Personal Weblog 1: http://kidehen.blogspot.com
Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen
Twitter Profile: https://twitter.com/kidehen
Google+ Profile: https://plus.google.com/+KingsleyIdehen/about
LinkedIn Profile: http://www.linkedin.com/in/kidehen
Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
smime.p7s
Description: S/MIME Cryptographic Signature
Re: AJAR (WAS: Microsoft Access for RDF?)
On Tue, 2015-02-24 at 11:43 -0500, Kingsley Idehen wrote: It looks like that on the surface, but it simply boils down to: 1. Javascript 2. Ajar (Asynchronous JavaScript and RDF) -- TimBL tried to kick of this Ajar meme a few years ago with limited uptake, but its darn neat!) Kingsley, do you have further references for AJAR? It sounds like the approach I stumbled onto while looking for a sensible way to make a heavy client for displaying RDF. In theory it could provide great power and simplicity, but I can't say I've worked through the initial complexity to prove the point. Regards, --Paul
Re: Microsoft Access for RDF?
Perhaps something interesting here https://github.com/jmvanel/semantic_forms -- Jean-Claude Moissinac 2015-02-23 10:34 GMT+01:00 Stian Soiland-Reyes soiland-re...@cs.manchester.ac.uk: On 21 February 2015 at 20:38, Michael Brunnbauer bru...@netestate.de wrote: I admit that what you sketch here is better than what I have sketched with named graphs. But it seems to require a very sophisticated editor or a very sophisticated user. Agreed that the editor needs to be more clever than three text fields with auto-complete. If a non-RDF user is to be making RDF, at a triple-level, then the editor must be guiding the user towards the basic Linked Data principles rather than be a glorified vim. :) I was talking about an editor where the user can add triples with arbitrary properties. .. and arbitrary properties/classes should include ones the user make up on the spot and relate it to existing properties/classes. Kingsley was talking about the sentences analogy, and I think we should keep this in mind. While you shouldn't normally write a whole book using your own terminology, it's very common to introduce at least SOME terminology that you specify or clarify for the scope of the text (e.g. the document, graph, dataset). It could be something as in a triple (a sentence), show something as simple as a little [+] button next to the property or class to specialize it and use this instead in that triple. (making it available for other triples) Perhaps Kingsley's approach have some mechanism for specializing or introducing new properties? So I would prefer the solution with named graphs that can be implemented easily. Yes, the additional information will be very vague without context but it will at least be there. I wouldn't dismiss the named graphs-per-triple approach - although to me it sounds overkill (perhaps one named graph per transaction). However starting to encode relations between those named graphs to make them sequential (and thus encode some hidden semantic meaning) to me feels a bit like trickery - your user isn't really making RDF statements the way we commonly find it in Linked Data world - he's making some kind of custom graph-ordering-structure that is just represented in RDF. Using named graphs for provenance is however very much best practice - so if you just track the provenance of when triples were inserted and one of your views is to view the graph or statements about a subject in that order (present it as Insertion order or something), then you are good - you are not tricking the user anymore. You thus won't need to implement Move up buttons as you should not rewrite history. :) -- Stian Soiland-Reyes, eScience Lab School of Computer Science The University of Manchester http://soiland-reyes.com/stian/work/ http://orcid.org/-0001-9842-9718
Re: Microsoft Access for RDF?
On 2/23/15 5:20 AM, Jean-Claude Moissinac wrote: Perhaps something interesting here https://github.com/jmvanel/semantic_forms Great! BTW -- is there a live demo instance somewhere? -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
On 2/23/15 4:34 AM, Stian Soiland-Reyes wrote: On 21 February 2015 at 20:38, Michael Brunnbauer bru...@netestate.de wrote: I admit that what you sketch here is better than what I have sketched with named graphs. But it seems to require a very sophisticated editor or a very sophisticated user. Agreed that the editor needs to be more clever than three text fields with auto-complete. If a non-RDF user is to be making RDF, at a triple-level, then the editor must be guiding the user towards the basic Linked Data principles rather than be a glorified vim. :) I was talking about an editor where the user can add triples with arbitrary properties. .. and arbitrary properties/classes should include ones the user make up on the spot and relate it to existing properties/classes. Kingsley was talking about the sentences analogy, and I think we should keep this in mind. While you shouldn't normally write a whole book using your own terminology, it's very common to introduce at least SOME terminology that you specify or clarify for the scope of the text (e.g. the document, graph, dataset). It could be something as in a triple (a sentence), show something as simple as a little [+] button next to the property or class to specialize it and use this instead in that triple. (making it available for other triples) Perhaps Kingsley's approach have some mechanism for specializing or introducing new properties? It doesn't have that right now, but it will have such functionality in due course. This feature may or may not make the initial public release. At the current time, I use nanotation [1][2] as my mechanism to for achieving this goal. Ultimately, an RDF Editor should simply be an alternative to nantation that addresses the needs of those that don't want type RDF statements by hand, in any notation. Yes, they don't want to work with raw editors like: vi, vim, textmate, sublime etc.. Links: [1] http://kidehen.blogspot.com/2014/07/nanotation.html -- I can create RDF statements that define the nature of things and/or the things themselves [2] http://linkeddata.uriburner.com/c/8FWGFY -- results of nanotation in a tweet that include the definition of https://twitter.com/hashtag/shouldBeOfInterestTo#this [3] http://linkeddata.uriburner.com/fct/rdfdesc/usage.vsp?g=https%3A%2F%2Ftwitter.com%2Fhashtag%2FshouldBeOfInterestTo%23this -- named graphs (documents) that contain the RDF statements used to define this particular relation [basically, this was performed using a series of tweets] . -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
I just pushed the link for information I forward the question to the main author of the *semantic_forms https://github.com/jmvanel/semantic_forms* tool He is the best to answer about it. -- Jean-Claude Moissinac 2015-02-23 14:29 GMT+01:00 Kingsley Idehen kide...@openlinksw.com: On 2/23/15 5:20 AM, Jean-Claude Moissinac wrote: Perhaps something interesting here https://github.com/jmvanel/semantic_forms Great! BTW -- is there a live demo instance somewhere? -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
Re: Microsoft Access for RDF?
On 21 February 2015 at 20:38, Michael Brunnbauer bru...@netestate.de wrote: I admit that what you sketch here is better than what I have sketched with named graphs. But it seems to require a very sophisticated editor or a very sophisticated user. Agreed that the editor needs to be more clever than three text fields with auto-complete. If a non-RDF user is to be making RDF, at a triple-level, then the editor must be guiding the user towards the basic Linked Data principles rather than be a glorified vim. :) I was talking about an editor where the user can add triples with arbitrary properties. .. and arbitrary properties/classes should include ones the user make up on the spot and relate it to existing properties/classes. Kingsley was talking about the sentences analogy, and I think we should keep this in mind. While you shouldn't normally write a whole book using your own terminology, it's very common to introduce at least SOME terminology that you specify or clarify for the scope of the text (e.g. the document, graph, dataset). It could be something as in a triple (a sentence), show something as simple as a little [+] button next to the property or class to specialize it and use this instead in that triple. (making it available for other triples) Perhaps Kingsley's approach have some mechanism for specializing or introducing new properties? So I would prefer the solution with named graphs that can be implemented easily. Yes, the additional information will be very vague without context but it will at least be there. I wouldn't dismiss the named graphs-per-triple approach - although to me it sounds overkill (perhaps one named graph per transaction). However starting to encode relations between those named graphs to make them sequential (and thus encode some hidden semantic meaning) to me feels a bit like trickery - your user isn't really making RDF statements the way we commonly find it in Linked Data world - he's making some kind of custom graph-ordering-structure that is just represented in RDF. Using named graphs for provenance is however very much best practice - so if you just track the provenance of when triples were inserted and one of your views is to view the graph or statements about a subject in that order (present it as Insertion order or something), then you are good - you are not tricking the user anymore. You thus won't need to implement Move up buttons as you should not rewrite history. :) -- Stian Soiland-Reyes, eScience Lab School of Computer Science The University of Manchester http://soiland-reyes.com/stian/work/http://orcid.org/-0001-9842-9718
Re: Microsoft Access for RDF?
On 2/21/15 9:48 AM, Martynas Jusevičius wrote: How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. Okay, so your editor simply writes data assuming the destination (a store of some sort) handles conflicts, right? The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. Dealing with conflict is intrinsic to this problem space. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? No, I think it boils to down to implementations. A client or a server may or may not be engineered to deal with these matters. We scope the description edited either by a) SPARQL query or b) named graph content. Yes, but these activities will inevitably encounter conflicts, which take different shapes and forms: 1. one user performing insert, updates, deletes in random order 2. many users performing the activities above, close-to-concurrently . Ideally, the client should have the ability to determine a delta prior to its write attempt. The nature of the delta is affected by the relation in question. Similar issues arise in situations where relations are represented as tables, it just so happens that the destination store is a SQL RDBMS which has in-built functionality for handling these matters, via different concurrency and locking schemes (which can be at the record, table, or page levels). Bearing in mind what's stated above, ideally, an RDF Editor shouldn't assume it's writing to an RDBMS equipped with the kind of functionality that a typical SQL RDBMS would posses. Thus, it needs to have some kind of optimistic concurrency mechanism (over HTTP) that leverages the kind of grouping that named graphs, rdf relations, and rdf statement reification provide. To conclude, its a good thing that we are now talking about RDF Editors and Read-Write Web issues. The silence on this matter, in relation to Linked Open Data, has been deafening :) -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. You can look at such group as a resource which has properties. Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? We scope the description edited either by a) SPARQL query or b) named graph content. Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the
Re: Microsoft Access for RDF?
On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A _*predicate*_ is a sentence-forming _*relation*_. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) grouped by predicate . Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1] http://54.183.42.206:8080/sigma/Browse.jsp?lang=EnglishLanguageflang=SUO-KIFkb=SUMOterm=Predicate Kingsley Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? We scope the description edited either by a) SPARQL query or b) named graph content. Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise
Re: Microsoft Access for RDF?
Kingsley, I don't need a lecture from you each time you disagree. Please explain what you think Resource means in Resource Description Framework. In any case, I think you know well what I mean. A grouped RDF/XML output would be smth like this: rdf:Description rdf:about=http://resource; rdf:type rdf:resource=http://type/ a:propertyvalue/a:property b:propertysmth/b:property /rdf:Description How would you call this? I call it a resource description. But the name does not matter much, the fact is that we use it and it works. On Sat, Feb 21, 2015 at 7:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) grouped by predicate . Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1] http://54.183.42.206:8080/sigma/Browse.jsp?lang=EnglishLanguageflang=SUO-KIFkb=SUMOterm=Predicate Kingsley Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? We scope the description edited either by a) SPARQL query or b) named graph content. Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to
Re: Microsoft Access for RDF?
You could call it a Concise Bounded Description http://www.w3.org/Submission/CBD/ RDF is used to describe resources, most of which exist with or with RDF's help. :-) On Feb 21, 2015, at 1:39 PM, Martynas Jusevičius marty...@graphity.org wrote: Kingsley, I don't need a lecture from you each time you disagree. Please explain what you think Resource means in Resource Description Framework. In any case, I think you know well what I mean. A grouped RDF/XML output would be smth like this: rdf:Description rdf:about=http://resource; rdf:type rdf:resource=http://type/ a:propertyvalue/a:property b:propertysmth/b:property /rdf:Description How would you call this? I call it a resource description. But the name does not matter much, the fact is that we use it and it works. On Sat, Feb 21, 2015 at 7:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) grouped by predicate . Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1] http://54.183.42.206:8080/sigma/Browse.jsp?lang=EnglishLanguageflang=SUO-KIFkb=SUMOterm=Predicate Kingsley Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? We scope the description edited either by a) SPARQL query or b) named graph content. Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So
Re: Microsoft Access for RDF?
Hey Michael, the resource description being edited is loaded with a SPARQL query. The updated description is inserted using SPARQL update. Although often it is useful to edit and update full content from a named graph using Graph Store Protocol instead. So view and update mechanisms are not necessarily symmetrical. Triple objects also can ordered alphabetically? We use ordering resources by properties (e.g. container items) a lot, but it is more relevant in the view case than in the edit case. Does that answer your question? If not, I'm not exactly sure what kind of ordering you are referring to, or why it is relevant. On Fri, Feb 20, 2015 at 8:49 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, On Fri, Feb 20, 2015 at 06:04:49PM +0100, Martynas Jusevi??ius wrote: The layout is generated with XSLT from RDF/XML. The triples are grouped by resources. Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. So the ordering of triple objects cannot be controlled by the user and this ordering is not relevant for your use case? Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel
Re: Microsoft Access for RDF?
On 2/21/15 2:57 PM, Martynas Jusevičius wrote: Kingsley, I am fully aware of the distinction between RDF as a data model and its serializations. That's why I wrote: RDF *serializations* often group triples by subject URI. What I tweeted recently was, that despite having concept models and abstractions in our heads, when pipelining data and writing software we are dealing with concrete serializations. Am I not right? Trouble here is that we have a terminology problem. If I disagree with you (about terminology), it is presumed I am lecturing. FWIW -- serialization formats, notations, and languages are not the same thing. Unfortunately, all of these subtly distinct items are conflated in RDF-land. So what I mean with it works is that our RDF/POST-based user interface is simply a generic function of the RDF graph behind it, in the form of XSLT transforming the RDF/XML serialization. I commented on concurrency in the previous email, but you haven't replied to that. I'll go find that comment, and respond if need be. Otherwise, I would rather just make time to use your RDF editing tool and provide specific usage feedback, in regards to the issues of concern and interest to me. Kingsley On Sat, Feb 21, 2015 at 8:43 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 1:34 PM, Martynas Jusevičius wrote: Kingsley, I don't need a lecture from you each time you disagree. I am not lecturing you. I am trying to make the conversation clearer. Can't you see that? Please explain what you think Resource means in Resource Description Framework. In any case, I think you know well what I mean. A grouped RDF/XML output would be smth like this: rdf:Description rdf:about=http://resource; rdf:type rdf:resource=http://type/ a:propertyvalue/a:property b:propertysmth/b:property /rdf:Description You spoke about RDF not RDF/XML (as you know, they are not the same thing). You said or implied RDF datasets are usually organized by subject. RDF is an abstract Language (system of signs, syntax, and semantics). Thus, why are you presenting me with an RDF/XML statement notation based response, when we are debating/discussing the nature of an RDF relation? Can't you see that the more we speak about RDF in overloaded-form the more confusing it remains? RDF isn't a mystery. It doesn't have to be some unsolvable riddle. Sadly, that's its general perception because we talk about it using common terms in an overloaded manner. How would you call this? I call it a resource description. See my comments above. RDF is a Language. You can create RDF Statements in a document using a variety of Notations. Thus, when speaking of RDF I am not thinking about RDF/XML, TURTLE, or any other notation. I am thinking about a language that systematically leverages signs, syntax, and semantics as a mechanism for encoding and decoding information [data in some context]. But the name does not matter much, the fact is that we use it and it works. Just works in what sense? That's why I asked you questions about how you catered to integrity and concurrency. If you have more than one person editing sentences, paragraphs, or a page in a book, wouldn't you think handling issues such as the activity frequency, user count, and content volume are important? That's all I was seeking an insight from you about, in regards to your work. Kingsley On Sat, Feb 21, 2015 at 7:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over
Re: Microsoft Access for RDF?
On 2/21/15 1:58 PM, Pat Hayes wrote: On Feb 21, 2015, at 12:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. Sure it is. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, Indeed. All the RDF relations are binary, so this is overkill, but... and inconsistent with the subject ordering claims you are making. Not in the least. Pat, There is no implicit ordering in RDF. The claim RDF serializations often group triples by subject URI is close to inferring a common practice ordering, when such isn't specified. An application, e.g., the kind that's created this thread (i.e., an RDF Editor) could decide to order RDF statements by Subject, but it has implications. The very editor we will soon be releasing offers that kind of ordering, but not as the sole option. At the start of this RDF Editor thread, I tried to bring a specific metaphor (Book [RDF Source], Pages [Named Graphs], Paragraphs [RDF Statements grouped by Predicate], and Sentences [RDF Statements]) into scope so that we had a simple basis for understanding issues that arise in a multi-user editor -- where operation atomicity is important, without totally killing concurrency. As we already know from RDBMS experience in general, an RDF Editor (a client to a store) needs to be able to leverage optimistic concurrency, which may not actually match the UI/UX interaction experience of the user i.e., they see one thing, but at actual data persistence time something else is happening in regards to the actual atomic units that are subject to comparison with the original RDF source prior to actual persistence. RDF Editors are not a trivial matter, which is why after 14+ years we only beginning to attend to this issue as a matter of course re., the broader Linked Open Data cloud. RDF triples can be organized in any way that suits the user, including by common subject if that is thought to be useful or intuitive. Sets of RDF 3-tuples can be *ordered* in an app UI/UX as the developer sees fit, again there's no golden rule (including approaches that produce unusable apps that struggle with integrity and concurrency as data size and concurrent users increase) . RDF 3-tuples are organized in line with RDF syntax rules. Assuming organize implies how an RDF 3-tuple (triple) is arranged, hence the subject-predicate-object structure. The RDF spec says nothing about how triples are to be ordered or organized. I never said or implied it did. I simply referred to the nature of an RDF relation. Basically, what rdf:Property is about. RDF/XML syntax assumes a by-subject organization and so provides abbreviations which only work for that. You know this already, but I just have to reply to your comment (we have an audience): RDF/XML != RDF :) I wasn't replying to a question about RDF/XML, and I don't believe (circa. 2015) that RDF datasets are typically in RDF/XML form. That's not what I see these days, and I work with a lot of RDF data (not a secret to you or anyone else). RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) yes, but grouped by predicate . Not necessarily. They can be grouped any way you like. Yes, they can be grouped in an application, however the developer chooses, but that isn't what I was refuting or even concerned about. My real concern boils down to an RDF Editor that can work against big or large RDF data sources without ignoring fundamental
Re: Microsoft Access for RDF?
On 2/21/15 1:34 PM, Martynas Jusevičius wrote: Kingsley, I don't need a lecture from you each time you disagree. I am not lecturing you. I am trying to make the conversation clearer. Can't you see that? Please explain what you think Resource means in Resource Description Framework. In any case, I think you know well what I mean. A grouped RDF/XML output would be smth like this: rdf:Description rdf:about=http://resource; rdf:type rdf:resource=http://type/ a:propertyvalue/a:property b:propertysmth/b:property /rdf:Description You spoke about RDF not RDF/XML (as you know, they are not the same thing). You said or implied RDF datasets are usually organized by subject. RDF is an abstract Language (system of signs, syntax, and semantics). Thus, why are you presenting me with an RDF/XML statement notation based response, when we are debating/discussing the nature of an RDF relation? Can't you see that the more we speak about RDF in overloaded-form the more confusing it remains? RDF isn't a mystery. It doesn't have to be some unsolvable riddle. Sadly, that's its general perception because we talk about it using common terms in an overloaded manner. How would you call this? I call it a resource description. See my comments above. RDF is a Language. You can create RDF Statements in a document using a variety of Notations. Thus, when speaking of RDF I am not thinking about RDF/XML, TURTLE, or any other notation. I am thinking about a language that systematically leverages signs, syntax, and semantics as a mechanism for encoding and decoding information [data in some context]. But the name does not matter much, the fact is that we use it and it works. Just works in what sense? That's why I asked you questions about how you catered to integrity and concurrency. If you have more than one person editing sentences, paragraphs, or a page in a book, wouldn't you think handling issues such as the activity frequency, user count, and content volume are important? That's all I was seeking an insight from you about, in regards to your work. Kingsley On Sat, Feb 21, 2015 at 7:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) grouped by predicate . Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1] http://54.183.42.206:8080/sigma/Browse.jsp?lang=EnglishLanguageflang=SUO-KIFkb=SUMOterm=Predicate Kingsley Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph
Re: Microsoft Access for RDF?
Kingsley, I am fully aware of the distinction between RDF as a data model and its serializations. That's why I wrote: RDF *serializations* often group triples by subject URI. What I tweeted recently was, that despite having concept models and abstractions in our heads, when pipelining data and writing software we are dealing with concrete serializations. Am I not right? So what I mean with it works is that our RDF/POST-based user interface is simply a generic function of the RDF graph behind it, in the form of XSLT transforming the RDF/XML serialization. I commented on concurrency in the previous email, but you haven't replied to that. On Sat, Feb 21, 2015 at 8:43 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 1:34 PM, Martynas Jusevičius wrote: Kingsley, I don't need a lecture from you each time you disagree. I am not lecturing you. I am trying to make the conversation clearer. Can't you see that? Please explain what you think Resource means in Resource Description Framework. In any case, I think you know well what I mean. A grouped RDF/XML output would be smth like this: rdf:Description rdf:about=http://resource; rdf:type rdf:resource=http://type/ a:propertyvalue/a:property b:propertysmth/b:property /rdf:Description You spoke about RDF not RDF/XML (as you know, they are not the same thing). You said or implied RDF datasets are usually organized by subject. RDF is an abstract Language (system of signs, syntax, and semantics). Thus, why are you presenting me with an RDF/XML statement notation based response, when we are debating/discussing the nature of an RDF relation? Can't you see that the more we speak about RDF in overloaded-form the more confusing it remains? RDF isn't a mystery. It doesn't have to be some unsolvable riddle. Sadly, that's its general perception because we talk about it using common terms in an overloaded manner. How would you call this? I call it a resource description. See my comments above. RDF is a Language. You can create RDF Statements in a document using a variety of Notations. Thus, when speaking of RDF I am not thinking about RDF/XML, TURTLE, or any other notation. I am thinking about a language that systematically leverages signs, syntax, and semantics as a mechanism for encoding and decoding information [data in some context]. But the name does not matter much, the fact is that we use it and it works. Just works in what sense? That's why I asked you questions about how you catered to integrity and concurrency. If you have more than one person editing sentences, paragraphs, or a page in a book, wouldn't you think handling issues such as the activity frequency, user count, and content volume are important? That's all I was seeking an insight from you about, in regards to your work. Kingsley On Sat, Feb 21, 2015 at 7:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, and inconsistent with the subject ordering claims you are making. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) grouped by predicate . Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1]
Re: Microsoft Access for RDF?
On Feb 21, 2015, at 12:01 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/21/15 9:48 AM, Martynas Jusevičius wrote: On Fri, Feb 20, 2015 at 6:41 PM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Well, RDF stands for Resource Description Framework after all, so I'll cite its spec: RDF graphs are sets of subject-predicate-object triples, where the elements may be IRIs, blank nodes, or datatyped literals. They are used to express descriptions of resources. More to the point, RDF serializations often group triples by subject URI. The claim often group triples by subject isn't consistent with the nature of an RDF Relation [1]. Sure it is. A predicate is a sentence-forming relation. Each tuple in the relation is a finite, ordered sequence of objects. The fact that a particular tuple is an element of a predicate is denoted by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the objects so related. In the case of binary predicates, the fact can be read as `arg_1 is *predicate* arg_2' or `a *predicate* of arg_1 is arg_2'.) [1] . RDF's specs are consistent with what's described above, Indeed. All the RDF relations are binary, so this is overkill, but... and inconsistent with the subject ordering claims you are making. Not in the least. RDF triples can be organized in any way that suits the user, including by common subject if that is thought to be useful or intuitive. The RDF spec says nothing about how triples are to be ordered or organized. RDF/XML syntax assumes a by-subject organization and so provides abbreviations which only work for that. RDF statements (which represent relations) have sources such as documents which are accessible over a network and/or documents managed by some RDBMS e.g., Named Graphs in the case of a SPARQL compliant RDBMS . In RDF you are always working with a set of tuples (s,p,o 3-tuples specifically) yes, but grouped by predicate . Not necessarily. They can be grouped any way you like. Pat Also note, I never used the phrase RDF Graph in any of the sentences above, and deliberately so, because that overloaded phrase is yet another source of unnecessary confusion. Links: [1] http://54.183.42.206:8080/sigma/Browse.jsp?lang=EnglishLanguageflang=SUO-KIFkb=SUMOterm=Predicate Kingsley Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? I don't think concurrent updates I related to resources or specific to our editor. The Linked Data platform (whatever it is) and its HTTP logic has to deal with ETags and 409 Conflict etc. I was wondering if this logic should be part of specifications such as the Graph Store Protocol: https://twitter.com/pumba_lt/status/545206095783145472 But I haven't an answer. Maybe it's an oversight on the W3C side? We scope the description edited either by a) SPARQL query or b) named graph content. Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an
Re: Microsoft Access for RDF?
Hello Paul, I wouldn’t go as far as saying that OWL is a complete failure, but agree to most of those thoughts, especially: As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. +1 you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. What needs to be added here is that, in practice, you often even get unexpected and unwanted facts from OWL reasoning that might effectively break your database applications — especially if you are one of those average joes. As a data integration language OWL points in an interesting direction Again, +1. More than just interesting, it can even be an extremely valuable asset. And the other things you mention are in fact not addressed in OWL but could be solved in combination with other tools. — Going back to your original problem (first e-mail and Einstein example), you could in principle also use our Information Workbench [1]. It can connect to any SPARQL endoint (although a Sesame repository is the preferred method). The built-in interface for each URI looks like this one [2]. Note, that the interface is editable, including adding/removing/changing triples, though only for authenticated users (so it doesn’t show in the example). In addition, you could use templates to add better customized views/forms for certain types. Christoph [1] http://www.fluidops.com/en/company/training/open_source [2] http://conference-explorer.fluidops.net/resource/eswc:2014?view=table Christoph Pinkel Research Development Engineer christoph.pin...@fluidops.com mailto:christoph.pin...@fluidops.com T +49 6227 3580 87 – 50 fluid Operations AG | Altrottstrasse 31 | 69190 Walldorf | Germany | www.fluidops.com http://www.fluidops.com/ fluidOps – Semantifying Business Executive Board Dr. Andreas Eberhart, Dr. Stefan Kraus, Dr. Ulrich Walther | Supervisory Board Wolf Herzberger *, Prof. Dr. Andreas Reuter, Udo Tschira | Register Court Mannheim, HRB 709796 | VAT-No. DE258759786 * Chairman This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden. On 20 Feb 2015, at 16:09, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com mailto:j...@example.com and j...@example.com mailto:j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was
Re: Microsoft Access for RDF?
Hello Stian, I admit that what you sketch here is better than what I have sketched with named graphs. But it seems to require a very sophisticated editor or a very sophisticated user. I was talking about an editor where the user can add triples with arbitrary properties. So I would prefer the solution with named graphs that can be implemented easily. Yes, the additional information will be very vague without context but it will at least be there. Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 09:53:05PM +, Stian Soiland-Reyes wrote: Sorry, now I forgot my strawman! Too late on a Friday.. So say the user of an triple-order-preserving UI says: document prov:wasAttributedTo :alice, :charlie, :bob. .. And consider the order important because Bob didn't contribute as much to the document as Alice and Charlie. In that case the above statements is not detailed enough and some new property or resource is needed to represent this distinction in RDF. Here I would think OWL fear combined with desire to reuse existing vocabularies mean that you don't get specific enough. Its OK to state the same relation with two different properties, and even better to make a new sub property that explains the combination. In the strawman, using more specific properties like pav:authoredBy and prov:wasInfluencedBy would clarify the distinction much more than an ordered list with an unspecified order criteria. In other cases the property is really giving a shortcut, say; meeting :attendedBy :john, :alice, :charlie . ..And the user is also encoding arrival time at the meeting by the list order. But this is using :attendesBy to describe both who were there, and when they arrived. In this case, the event of arriving could better be modelled separately with a partial ordering. If you don't like double housekeeping (most programmers know the pitfalls here), then using OWL or inference rules you can also infer attendance from the arrival events. -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpZIDmCJtAgN.pgp Description: PGP signature
Re: Microsoft Access for RDF?
Hello Stian, On Fri, Feb 20, 2015 at 09:54:33AM +, Stian Soiland-Reyes wrote: So if you tell the user his information is just RDF, but neglect to mention and then some, he could wrongfully think that his list of say preferred president has its order preserved in any exposed RDF. Then tell the user his information is just a RDF dataset. My apologies, I got the impression there was a suggestion to control ordering of triples without making any collection statements. I would suggest to do that with named graphs. We are talking about a generic triple editor and IMO most properties are not compatible with collections. Of course, there would also be a default graph mode in the editor that does not use named graphs and does not support ordering. Don't let the user encode information he considers important in a way that is not preserved semantically. Named graphs can be queried via SPARQL. You can query the default (union) graph where this information would be lost or the named graphs where it is preserved semantically and publicly accessible. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgphihQ85nkXl.pgp Description: PGP signature
Re: Microsoft Access for RDF?
Hello Paul, On Thu, Feb 19, 2015 at 09:19:06PM +0100, Michael Brunnbauer wrote: Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? If one can put a container where a container is not explicitly sanctioned by the semantics of the property, then I have missed something important. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpChUwXQbAuk.pgp Description: PGP signature
Re: Microsoft Access for RDF?
On 19 Feb 2015 21:42, Kingsley Idehen kide...@openlinksw.com wrote: No, this is dangerous and is hiding the truth. What? (Just to clarify my view, obviously you know this :) ) That RDF Triples are not ordered in an RDF Graph. They might be ordered in something else, but that is not part of the RDF graph. (Reification statements can easily also become something else) So if you tell the user his information is just RDF, but neglect to mention and then some, he could wrongfully think that his list of say preferred president has its order preserved in any exposed RDF. If you don't tell him it is RDF (this is now the trend of Linked Data movement..), fine! It's just a technology - he doesn't need to know. You can describe collections using RDF statements, I don't have any idea how what I am talking about implies collection exclusion. My apologies, I got the impression there was a suggestion to control ordering of triples without making any collection statements. Don't let the user encode information he considers important in a way that is not preserved semantically. ?? I simply meant to not store such information out of band, e.g. by virtue of triple order or comments in a Turtle file, or by magic extra bits in some database that don't transfer along to other consumers of the produced RDF. It should be fine to store view-metadata out of bands (e.g. which field was last updated) - but if it has a conceptual meaning to the user I think it should also have meaning in the RDF and the vocabularies used. If you are able to transparently do the right thing semantically, then hurray! Why do you think we've built an RDF editor without factoring in OWL? Many people are still allergic to OWL :-( And also I am still eager to actually see what you are talking about rather than guessing! :-) I think we are better off waiting until we release our RDF Editor. We actually built this on the request of a vary large customer. This isn't a speculative endeavor. It's actually being used by said organization as I type Looking forward to have a go. Great that you will open source it!
Re: Microsoft Access for RDF?
Sorry, now I forgot my strawman! Too late on a Friday.. So say the user of an triple-order-preserving UI says: document prov:wasAttributedTo :alice, :charlie, :bob. .. And consider the order important because Bob didn't contribute as much to the document as Alice and Charlie. In that case the above statements is not detailed enough and some new property or resource is needed to represent this distinction in RDF. Here I would think OWL fear combined with desire to reuse existing vocabularies mean that you don't get specific enough. Its OK to state the same relation with two different properties, and even better to make a new sub property that explains the combination. In the strawman, using more specific properties like pav:authoredBy and prov:wasInfluencedBy would clarify the distinction much more than an ordered list with an unspecified order criteria. In other cases the property is really giving a shortcut, say; meeting :attendedBy :john, :alice, :charlie . ..And the user is also encoding arrival time at the meeting by the list order. But this is using :attendesBy to describe both who were there, and when they arrived. In this case, the event of arriving could better be modelled separately with a partial ordering. If you don't like double housekeeping (most programmers know the pitfalls here), then using OWL or inference rules you can also infer attendance from the arrival events.
Re: Microsoft Access for RDF?
On 2/20/15 1:19 PM, Graham Klyne wrote: Hi Stian, Thanks for the mention :) Graham Klyne's Annalist is perhaps not quite what you are thinking of (I don't think it can connect to an arbitrary SPARQL endpoint), but I would consider it as falling under a similar category, as you have a user interface to define record types and forms, browse and edit records, with views defined for different record types. Under the surface it is however all RDF and REST - so you are making a schema by stealth. http://annalist.net/ http://demo.annalist.net/ Annalist is still in its prototype phase, but it's available to play with if anyone wants to try stuff. See also https://github.com/gklyne/annalist for source. There's also a Dockerized version. It's true that Annalist does not currently connect to a SPARQL endpoint, but have recently been doing some RDF data wrangling and starting to think about how to connect to public RDF (e.g. http://demo.annalist.net/annalist/c/CALMA_data/d/ is a first attempt at creating an editable version of some music data from your colleague Sean). In this case, the record types and views have been created automatically from the raw data, and are pretty basic - but that automatic extraction can serve as a starting point for subsequent editing. (The reverse of this, creating an actual schema from the defined types and views, is an exercise for the future, or maybe even for a reader :) ) Internally, the underlying data access is isolated in a single module, intended to facilitate connecting to alternative backends, which could be via SPARQL access. (I'd also like to connect up with the linked data fragments work at some stage.) If this looks like something that could be useful to anyone out there, about now might be a good time to offer feedback. Once I have what I feel is a minimum viable product release, hopefully not too long now, I'm hoping to use feedback and collaborations to prioritize ongoing developments. #g -- It is very good and useful, in my eyes! My enhancement requests would be that you consider supporting of at least one of the following, in regards to storage I/O: 1. LDP 2. WebDAV 3. SPARQL Graph Protocol 4. SPARQL 1.1 Insert, Update, Delete. As for Access Controls on the target storage destinations, don't worry about that in the RDF editor itself, leave that to the storage provider [1] that supports any combination of the protocols above. Links: [1] http://kidehen.blogspot.com/2014/07/loosely-coupled-read-write-interactions.html -- Loosely-Coupled Read-Write Web pattern example. -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
This is what I meant in my earlier message when touching on collection. If the order of the resources (let's stick with foaf:Person) matter, then the property used should not have a range of (only) foaf:Person. So say One problem is that say in OWL you don't really have an easy way to type collections, e.g. ListPerson in Java. The rdf:List is integrated in multiple serializations, but has had issues with queries (sparql property paths help) and usage in OWL, where you easily get moanings about rdf: namespace being special. In OWL collections like co: you can use OWL restrictions to type collection members, but this does push OWL into AI land as mentioned earlier - OWL is not a schema language. When we made prov:Collection it was meant as a genetic upper type of a collection entity that could be used in-place of its members entities. http://www.w3.org/TR/prov-o/#Collection http://www.w3.org/TR/2013/REC-prov-dm-20130430/Overview.html#term-collection In the discussion for this, statements about a Collection, say policy prov:wasAttributedTo :theBoard . :theBoard a prov:Collection, prov:Agent ; prov:hadMember :alice, :bob, :charlie . Then you still can't conclude that: policy prov:wasAttributedTo :bob . as he might or might not have contributed to the policy document whilst on the board, but still is part-responsible for its creation (e.g. he didn't veto it). In the extension PROV Dictionary we agreed that order within a collection was often important, and that arbitrary literal keys as commonly used in JSON maps can have a meaning, even if just programmatic and not semantically detailed. A List can be just a dictionary using nonnegative integers as their keys. (But you would have no EndOfList markers or guarantee that all keys were described). http://www.w3.org/TR/2013/NOTE-prov-dictionary-20130430/#dictionary-ontological-definition You see the dictionary entries are here typed as prov:KeyValuePair, which imply that the value is a member of the collection. http://www.w3.org/TR/2013/NOTE-prov-dictionary-20130430/#dmembership-cmembership-inference This is very similar to how CO has done inference between hasElement and the property chain has item - hasElementContent using just OWL. http://www.essepuntato.it/lode/owlapi/http://purl.org/co/#d4e76 One great advantage of CO collections is that they can easily be subclassed and typed by restrictions, e.g. hasElement only foaf:Person Such collections can then be used as the range of a property in Union with foaf:Person. On 20 Feb 2015 19:32, Michael Brunnbauer bru...@netestate.de wrote: Hello Pat, On Fri, Feb 20, 2015 at 11:45:12AM -0600, Pat Hayes wrote: Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. I am seriously interested in your position on the topic. Do you say that anything goes as long as it stays satisfiable? Should I assume that some property applying to some container/collection also applies to its members (which seems to be the implicit assumption here)? Should I modify my SPARQL queries accordingly? Let me play the censor a bit more :-) Let's admit that Dan also means legal person with person. But not every group of individuals acting together is a legal person. The example here was a group of people co-authoring a paper. Also, the notion that foaf:Group is a subclass of foaf:Person does not make any sense to me. Why then introduce foaf:Group at all? Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel
Re: Microsoft Access for RDF?
If you don't like double housekeeping (most programmers know the pitfalls here), then using OWL or inference rules you can also infer attendance from the arrival events. Are most programmers who work for the Human Resources Department ignorant or just really scary ? It's Friday. Get thee to beer. Quickly. On Fri, 2/20/15, Stian Soiland-Reyes soiland-re...@cs.manchester.ac.uk wrote: Subject: Re: Microsoft Access for RDF? To: Michael Brunnbauer bru...@netestate.de Cc: public-lod@w3.org, Pat Hayes pha...@ihmc.us Date: Friday, February 20, 2015, 3:53 PM Sorry, now I forgot my strawman! Too late on a Friday.. So say the user of an triple-order-preserving UI says: document prov:wasAttributedTo :alice, :charlie, :bob. .. And consider the order important because Bob didn't contribute as much to the document as Alice and Charlie. In that case the above statements is not detailed enough and some new property or resource is needed to represent this distinction in RDF. Here I would think OWL fear combined with desire to reuse existing vocabularies mean that you don't get specific enough. Its OK to state the same relation with two different properties, and even better to make a new sub property that explains the combination. In the strawman, using more specific properties like pav:authoredBy and prov:wasInfluencedBy would clarify the distinction much more than an ordered list with an unspecified order criteria. In other cases the property is really giving a shortcut, say; meeting :attendedBy :john, :alice, :charlie . ..And the user is also encoding arrival time at the meeting by the list order. But this is using :attendesBy to describe both who were there, and when they arrived. In this case, the event of arriving could better be modelled separately with a partial ordering. If you don't like double housekeeping (most programmers know the pitfalls here), then using OWL or inference rules you can also infer attendance from the arrival events.
Re: Microsoft Access for RDF?
I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was the same as the length of the largest collection but now that I think about it I think I can do better than that) I don't feel so bad about most recursive structures because I don't think they will get that deep but I think LISP-Lists are evil at least when it comes to external memory and modern memory hierarchies.
Re: Microsoft Access for RDF?
On 2/20/15 4:54 AM, Stian Soiland-Reyes wrote:
On 19 Feb 2015 21:42, Kingsley Idehen kide...@openlinksw.com
mailto:kide...@openlinksw.com wrote:
No, this is dangerous and is hiding the truth.
What?
(Just to clarify my view, obviously you know this :) )
That RDF Triples are not ordered in an RDF Graph.
Correct.
They might be ordered in something else, but that is not part of the
RDF graph.
You can produce an order using:
select * where {graph named-graph-iri {?s ?p ?o}}
order by ?p
offset and limit can be used to create a paging mechanism, if required.
Subqueries can be used for further optimize when the named graph is very
large etc.
This UI would be for the user to alter relation subjects or objects.
Predicate alternation isn't an option in this UI. Basically, the user it
focused on relationship entities for a specific relationship type.
(Reification statements can easily also become something else)
UI leveraging Reification:
This provides an ability to let the user interact with a collection of
statements in a UI where subject, predicate, and objects can be altered.
Basically, they have a UX oriented towards sentence editing.
So if you tell the user his information is just RDF, but neglect to
mention and then some, he could wrongfully think that his list of
say preferred president has its order preserved in any exposed RDF.
Not the intent here at all.
If you don't tell him it is RDF (this is now the trend of Linked Data
movement..), fine! It's just a technology - he doesn't need to know.
In our case we are showcasing RDF as Language, and using the UI/UX to
bolster that point of view, using different UI/UX patterns to address
the different ways a user can create or alter relations.
You can describe collections using RDF statements, I don't have any
idea how what I am talking about implies collection exclusion.
My apologies, I got the impression there was a suggestion to control
ordering of triples without making any collection statements.
An RDF editor has to allow users create any kind of relation that's
possible in the RDF Language.
Don't let the user encode information he considers important in a
way that is not preserved semantically.
??
I simply meant to not store such information out of band, e.g. by
virtue of triple order or comments in a Turtle file, or by magic
extra bits in some database that don't transfer along to other
consumers of the produced RDF.
Okay, we don't do that. In fact, exposing relations as groups of rdf
statements grouped by predicate enables clients lever optimistic
concurrency patterns since they can make hash based checksums on the
predicate based grouping that are tested prior to final persistence on
the target store (SPARQL, WebDAV, LDP compliant).
It should be fine to store view-metadata out of bands (e.g. which
field was last updated) - but if it has a conceptual meaning to the
user I think it should also have meaning in the RDF and the
vocabularies used.
We have a View that works with Controls en route to Data Persistence at
storage location that supports one of: SPARQL 1.1 Insert, Update,
Delete, SPARQL Graph Protocol, LDP, and WebDAV . The Editor we've built
is Javascript based. It also makes use of rdfstore.js, our generic I/O
layer (also in Javascript) and a few other bits ontology lookups etc..,
plus some bits JQuery integration etc..
If you are able to transparently do the right thing semantically,
then hurray!
I think we do, but we'll see what everyone thinks once its released :)
Why do you think we've built an RDF editor without factoring in OWL?
Many people are still allergic to OWL :-(
We aren't :)
And also I am still eager to actually see what you are talking about
rather than guessing! :-)
I think we are better off waiting until we release our RDF Editor.
We actually built this on the request of a vary large customer. This
isn't a speculative endeavor. It's actually being used by said
organization as I type
Looking forward to have a go. Great that you will open source it!
Okay.
--
Regards,
Kingsley Idehen
Founder CEO
OpenLink Software
Company Web: http://www.openlinksw.com
Personal Weblog 1: http://kidehen.blogspot.com
Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen
Twitter Profile: https://twitter.com/kidehen
Google+ Profile: https://plus.google.com/+KingsleyIdehen/about
LinkedIn Profile: http://www.linkedin.com/in/kidehen
Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
smime.p7s
Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was the same as the length of the largest collection but now that I think about it I think I can do better than that) I don't feel so bad about most recursive structures because I don't think they will get that deep but I think LISP-Lists are evil at least when it comes to external memory and modern memory hierarchies.
Re: Microsoft Access for RDF?
On 2/20/15 10:23 AM, Martynas Jusevičius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. That's because dog-fooding hasn't yet become second nature, across the aforementioned communities. Don't give up, just keep pushing the case via real examples etc.. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. Yes, that is the general case, but don't give up. Keep pushing, things will change, they have too! So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Please keep up your good work and overall effort in general. Don't get frustrated (I know that's easier said than done). RDF Editors are vital, in regards to bootstrapping a Read-Write Linked Open Data ecosystem. The more the merrier, as long as the solutions in question are based on open standards (RDF, SPARQL, LDP, HTTP, URIs, WebDAV etc..). Kingsley Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was the same as the length of the largest collection but now that I think about it I think I can do better than that) I don't feel so bad about most recursive structures because I don't think they will get that deep but I think LISP-Lists are evil at least when it comes to external memory and modern memory hierarchies. -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was the same as the length of the largest collection but now that I think about it I think I can do better than that) I don't feel so bad about most recursive structures because I don't think they will get that deep but I think LISP-Lists are evil at least when it comes to external memory and modern memory hierarchies. -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpPXP1tggEvs.pgp Description: PGP signature
Re: Microsoft Access for RDF?
On 2/20/15 10:09 AM, Paul Houle wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. I think that's a little too generic a comment. Describing the nature of relations using relations is vital. Not all of OWL is vital, at the onset. Basically, OWL doesn't need to be at the front-door per se., but understanding its role, in regards to relations semantics description and exploitation is important. RDF/XML's problems have tarnished OWL, as it has the notion of a Semantic Web in general. For starters, too many OWL usage examples (circa., 2105) are *still* presented using RDF/XML :( The creation and management of RDF/XML is THE real problem. It messed up everything, and stayed at the fore front (as the sole official W3C RDF notation standard) for way too long. Exponential decadence++ par excellence! As a way of documenting types and properties it is tolerable. Methinks, very useful. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. You need both, with rules being much clearer starting points for users and developers. It's a journey back to Prolog [1] i.e., long awaited 5GL == Webby Prolog. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com mailto:j...@example.com and j...@example.com mailto:j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. Task better handled via rules. Links: [1] http://www.jfsowa.com/logic/prolog1.htm -- A Prolog to Prolog by John F. Sowa (Last Modified: 11/07/2001 14:13:17) . -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
On Feb 20, 2015, at 2:42 AM, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, On Thu, Feb 19, 2015 at 09:19:06PM +0100, Michael Brunnbauer wrote: Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. Pat If one can put a container where a container is not explicitly sanctioned by the semantics of the property, then I have missed something important. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel IHMC (850)434 8903 home 40 South Alcaniz St.(850)202 4416 office Pensacola(850)202 4440 fax FL 32502 (850)291 0667 mobile (preferred) pha...@ihmc.us http://www.ihmc.us/users/phayes
Re: Microsoft Access for RDF?
On 2/20/15 12:04 PM, Martynas Jusevičius wrote: Hey Michael, this one indeed. The layout is generated with XSLT from RDF/XML. The triples are grouped by resources. Not to criticize, but to seek clarity: What does the term resources refer to, in your usage context? In a world of Relations (this is what RDF is about, fundamentally) its hard for me to understand what you mean by grouped by resources. What is the resource etc? Within a resource block, properties are sorted alphabetically by their rdfs:labels retrieved from respective vocabularies. How do you handle the integrity of multi-user updates, without killing concurrency, using this method of grouping (which in of itself is unclear due to the use resources term) ? How do you minimize the user interaction space i.e., reduce clutter -- especially if you have a lot of relations in scope or the possibility that such becomes the reality over time? Kingsley On Fri, Feb 20, 2015 at 4:59 PM, Michael Brunnbauer bru...@netestate.de wrote: Hello Martynas, sorry! You mean this one? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Nice! Looks like a template but you still may have the triple object ordering problem. Do you? If yes, how did you address it? Regards, Michael Brunnbauer On Fri, Feb 20, 2015 at 04:23:14PM +0100, Martynas Jusevi??ius wrote: I find it funny that people on this list and semweb lists in general like discussing abstractions, ideas, desires, prejudices etc. However when a concrete example is shown, which solves the issue discussed or at least comes close to that, it receives no response. So please continue discussing the ideal RDF environment and its potential problems while we continue improving our editor for users who manage RDF already now. Have a nice weekend everyone! On Fri, Feb 20, 2015 at 4:09 PM, Paul Houle ontolo...@gmail.com wrote: So some thoughts here. OWL, so far as inference is concerned, is a failure and it is time to move on. It is like RDF/XML. As a way of documenting types and properties it is tolerable. If I write down something in production rules I can generally explain to an average joe what they mean. If I try to use OWL it is easy for a few things, hard for a few things, then there are a few things Kendall Clark can do, and then there is a lot you just can't do. On paper OWL has good scaling properties but in practice production rules win because you can infer the things you care about and not have to generate the large number of trivial or otherwise uninteresting conclusions you get from OWL. As a data integration language OWL points in an interesting direction but it is insufficient in a number of ways. For instance, it can't convert data types (canonicalize mailto:j...@example.com and j...@example.com), deal with trash dates (have you ever seen an enterprise system that didn't have trash dates?) or convert units. It also can't reject facts that don't matter and so far as both timespace and accuracy you do much easier if you can cook things down to the smallest correct database. The other one is that as Kingsley points out, the ordered collections do need some real work to square the circle between the abstract graph representation and things that are actually practical. I am building an app right now where I call an API and get back chunks of JSON which I cache, and the primary scenario is that I look them up by primary key and get back something with a 1:1 correspondence to what I got. Being able to do other kind of queries and such is sugar on top, but being able to reconstruct an original record, ordered collections and all, is an absolute requirement. So far my infovore framework based on Hadoop has avoided collections, containers and all that because these are not used in DBpedia and Freebase, at least not in the A-Box. The simple representation that each triple is a record does not work so well in this case because if I just turn blank nodes into UUIDs and spray them across the cluster, the act of reconstituting a container would require an unbounded number of passes, which is no fun at all with Hadoop. (At first I though the # of passes was the same as the length of the largest collection but now that I think about it I think I can do better than that) I don't feel so bad about most recursive structures because I don't think they will get that deep but I think LISP-Lists are evil at least when it comes to external memory and modern memory hierarchies. -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel -- Regards, Kingsley Idehen Founder CEO
Re: Microsoft Access for RDF?
Hi All, The infrastructure used in [1,2] to get transparency and auditability may be of interest for this discussion. Thanks for comments, -- Adrian [1] www.astd.org/Publications/Magazines/The-Public-Manager/Archives/2013/Fall/Social-Knowledge-Transfer-Using-Executable-English [2] www.reengineeringllc.com/demo_agents/GrowthAndDebt1.agent On Fri, Feb 20, 2015 at 12:45 PM, Pat Hayes pha...@ihmc.us wrote: On Feb 20, 2015, at 2:42 AM, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, On Thu, Feb 19, 2015 at 09:19:06PM +0100, Michael Brunnbauer wrote: Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. Pat If one can put a container where a container is not explicitly sanctioned by the semantics of the property, then I have missed something important. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel IHMC (850)434 8903 home 40 South Alcaniz St.(850)202 4416 office Pensacola(850)202 4440 fax FL 32502 (850)291 0667 mobile (preferred) pha...@ihmc.us http://www.ihmc.us/users/phayes
Re: Microsoft Access for RDF?
Hi All, The infrastructure used in [1,2] to get transparency and auditability may be of interest for this discussion. Thanks for comments, -- Adrian [1] www.astd.org/Publications/Magazines/The-Public-Manager/Archives/2013/Fall/Social-Knowledge-Transfer-Using-Executable-English [2] www.reengineeringllc.com/demo_agents/GrowthAndDebt1.agent On Fri, Feb 20, 2015 at 12:45 PM, Pat Hayes pha...@ihmc.us wrote: On Feb 20, 2015, at 2:42 AM, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, On Thu, Feb 19, 2015 at 09:19:06PM +0100, Michael Brunnbauer wrote: Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. Pat If one can put a container where a container is not explicitly sanctioned by the semantics of the property, then I have missed something important. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel IHMC (850)434 8903 home 40 South Alcaniz St.(850)202 4416 office Pensacola(850)202 4440 fax FL 32502 (850)291 0667 mobile (preferred) pha...@ihmc.us http://www.ihmc.us/users/phayes
Re: Microsoft Access for RDF?
Hi Stian, Thanks for the mention :) Graham Klyne's Annalist is perhaps not quite what you are thinking of (I don't think it can connect to an arbitrary SPARQL endpoint), but I would consider it as falling under a similar category, as you have a user interface to define record types and forms, browse and edit records, with views defined for different record types. Under the surface it is however all RDF and REST - so you are making a schema by stealth. http://annalist.net/ http://demo.annalist.net/ Annalist is still in its prototype phase, but it's available to play with if anyone wants to try stuff. See also https://github.com/gklyne/annalist for source. There's also a Dockerized version. It's true that Annalist does not currently connect to a SPARQL endpoint, but have recently been doing some RDF data wrangling and starting to think about how to connect to public RDF (e.g. http://demo.annalist.net/annalist/c/CALMA_data/d/ is a first attempt at creating an editable version of some music data from your colleague Sean). In this case, the record types and views have been created automatically from the raw data, and are pretty basic - but that automatic extraction can serve as a starting point for subsequent editing. (The reverse of this, creating an actual schema from the defined types and views, is an exercise for the future, or maybe even for a reader :) ) Internally, the underlying data access is isolated in a single module, intended to facilitate connecting to alternative backends, which could be via SPARQL access. (I'd also like to connect up with the linked data fragments work at some stage.) If this looks like something that could be useful to anyone out there, about now might be a good time to offer feedback. Once I have what I feel is a minimum viable product release, hopefully not too long now, I'm hoping to use feedback and collaborations to prioritize ongoing developments. #g --
Re: Microsoft Access for RDF?
Pat, so far as corporation is a person that is what we have foaf:Agent for. A corporation can sign contracts and be an endpoint for communication and payments the same as a person so to model the world of law, business, finance and stuff that is a very real thing. If you take that idea too literally, however, it conflicts with a person is an animal in terms of physiology, but that too can be modelled. Cristoph, the trouble with OWL is that things that almost work have a way of displacing things that do work, particularly in a community that has the incentive structures that the semweb community has. We have the problem of a really bad rep in many circles, I see people say stuff like this all the time http://lemire.me/blog/archives/2014/12/02/when-bad-ideas-will-not-die-from-classical-ai-to-linked-data/ and I have to admit that back in 2004 I was the guy who stood in the back of the conference room and said isn't this like the stuff they tried in the 80's that didn't work. A lot of people believe that guff, and combine that with the road rage of people who look for US states in DBpedia and find that 3 of them got dropped on the floor, it can be very hard to get taken seriously. Lemire's unconstructive criticism displaces real criticism, but that kind of criticism could be displaced by constructive criticism about the standards we have. For instance, I think RDF Data Shapes is a great idea but I needed it back in 2007 and it just astonishing to me that it took so long for it to happen. (Now I must admit I am most curious about why it is standards for rules interchange, i.e. the RuleML family, KIF, and a few others have had such a hard time going, whereas you find things like Drools, Blaze Advisor, and iLog running many real world systems.) On Fri, Feb 20, 2015 at 12:45 PM, Pat Hayes pha...@ihmc.us wrote: On Feb 20, 2015, at 2:42 AM, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, On Thu, Feb 19, 2015 at 09:19:06PM +0100, Michael Brunnbauer wrote: Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. Pat If one can put a container where a container is not explicitly sanctioned by the semantics of the property, then I have missed something important. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel IHMC (850)434 8903 home 40 South Alcaniz St.(850)202 4416 office Pensacola(850)202 4440 fax FL 32502 (850)291 0667 mobile (preferred) pha...@ihmc.us http://www.ihmc.us/users/phayes -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup
Re: Microsoft Access for RDF?
Hello Pat, On Fri, Feb 20, 2015 at 11:45:12AM -0600, Pat Hayes wrote: Another simpler example would be property rdfs:range foaf:Person. http://xmlns.com/foaf/spec/#term_Person says that Something is a Person if it is a person. How can an RDF container of several persons be a person? According the US Supreme Court a corporation is a person, so I would guess that a mere container would have no trouble geting past the censors. I am seriously interested in your position on the topic. Do you say that anything goes as long as it stays satisfiable? Should I assume that some property applying to some container/collection also applies to its members (which seems to be the implicit assumption here)? Should I modify my SPARQL queries accordingly? Let me play the censor a bit more :-) Let's admit that Dan also means legal person with person. But not every group of individuals acting together is a legal person. The example here was a group of people co-authoring a paper. Also, the notion that foaf:Group is a subclass of foaf:Person does not make any sense to me. Why then introduce foaf:Group at all? Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpXp_61os0Ig.pgp Description: PGP signature
Re: Microsoft Access for RDF?
Hello Paul, On Thu, Feb 19, 2015 at 12:27:41PM -0500, Paul Houle wrote: I think you're particular concerned about the ordering of triples where ?s and ?p are the same? ?s ?p ?o1 , ?o2, ?o3, ?o4 . right? The case for ?s ?p is more compelling but that does not mean that the case for ?s should be dropped. One scenario is we are drawing a page about the creative works of Issac Asimov, the Kinks, or Jeff Bridges and want to see titles that everybody recognizes at the top of the list. In some of these cases there is a subjective element in that there is no global total ordering or even a partial ordering (see Arrow's Theorem), but it's fair to say more people know the song Lola than Ducks on the Wall. Don't forget the use case where the user wants to have his ordering and not some global ordering. Does Arrow's Theorem say something about partial orderings? The Wikipedia article about Arrow's Theorem talks about complete rankings, which I take to mean total ordering. With RDF* you can put on edge weights which will support cases like that. This means automatically generated edge weights? Doesn't this assume that a reasonable number of people have made the same statement before and that the editor has has to somehow find this number and compare it with other numbers or get the edge weight from a central service? Another approach is to further specify the data model so you get behavior like hashtables in PHP -- PHP hashtables support random access look up but if you iterate over them things come out in the order you put them in. I am not sure I understand this. How would this look like? Triples about MD5-hashes of serialized triples? Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core How do you bring this in line with property rdfs:range datatype, especially property rdfs:range rdf:langString? I do not see a contradiction but this makes things quite ugly. How about all the SPARQL queries that assume a literal as object and not a RDF container? It's definitely a tooling issue but it does involve looking at hard issues in the underlying data model. You can definitely solve it with one named graph per triple - which may look like a hard issue for some people. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpoFCoCXYErc.pgp Description: PGP signature
Re: Microsoft Access for RDF?
On 2/19/15 1:40 PM, Bo Ferri wrote: Hi Paul, maybe I'm wrong, but I think what you are generally looking for (in the Semantic Web world) is the things that are going on at RDF Shapes group [1], or (but I guess you are aware of them)? What they can't do (yet; afaik) is the family instance loop check, or? On 2/18/2015 11:59 PM, Paul Houle wrote: For small projects you don't need access controls, provenance and that kind of thing, but if you were trying to run something like Freebase and Wikidata where you know what the algebra is the obvious thing to do is use RDF* and SPARQL*. No, why? - Wikidata's data model goes beyond RDF (triple based statements) for good reason. I'm always wondering why the heck we true Semantic Web developer still insist so hard on our beloved RDF (which all its drawbacks). Huh? Look forward. Think property graph and graph databases in general ;) What? You can also combine both perfectly, see, e.g., this graph data model [3] - RDF compatible, but able to store qualified attributes (e.g. order or provenance) at statement basis (without reification et. al). RDF is a Language, poorly promoted as a Data Model (a term which is ultimately a can of worms, exemplified by all the confusion its inflicted on everyone to date). Re. editing of graph information, you may have a look at OrientDB's graph editor [4], which offers neat editing options direct in the graph (yay!). Seriously? I do not know of a single so-called Graph Database that even comprehends the concept of data de-silo-fication [1][2][3][4]. Basically, for data to flow it can only do so via identifiers that resolve to descriptions using a platform agnostic protocol. Data is represented using relations [5][6]. RDF is a Data Representation Language [7]. Links: [1] https://www.pinterest.com/pin/389561436492223291/ -- What sits between You and Your data [2] http://twitter.com/kidehen/status/567723528318124033 -- Open Database Connectivity vs Open Data Connectivity [3] http://kidehen.blogspot.com/2014/08/linked-local-data-lld-and-linked-open.html -- Linked Local Data vs Linked Open Data [4] https://www.pinterest.com/pin/389561436493662240/ -- What RDF is about, illustrated (as they say: a picture speaks a thousand words) [5] http://twitter.com/kidehen/status/568462066207625216 -- What is a Relation? [6] http://twitter.com/kidehen/status/568461114129956864 -- What is a Predicate? [7] http://www.slideshare.net/kidehen/understanding-29894555/55 -- RDF is a Language . Kingsley Cheers, Bo [1] http://www.w3.org/2014/data-shapes/wiki/Main_Page [2] http://en.wikipedia.org/wiki/Graph_database [3] https://github.com/dswarm/dswarm-documentation/wiki/Graph-Data-Model [4] http://www.orientechnologies.com/docs/2.0/orientdb-studio.wiki/Graph-Editor.html -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
Hi Paul, I’ve looked at your initial msg 22 responses, including the Albert Einstein references that detail your requirements. If I may rephrase your question, you appear to be looking for something simple for non-technical people to use, thus the “Access” reference. Also, you appear to need a tool that is template-driven in order to create Web forms for viewing and editing semi structured data. Further, you’d like this tool to be 1) Linked Data aware and 2) able to query any SPARQL endpoint you point it to, and 3) it must be Web scale. If that is a fair summary of requirements, I encourage you to look at the Callimachus Open Source Project.[1] Callimachus helps Web developers create linked data based applications. Code is on GitHub.[2] Callimachus is an IDE for data-driven apps. It is database agnostic and can speak to any SPARQL v1.1 compliant endpoint, including but not limited to GraphDB, MarkLogic 8, AllegroGraph and StarDog. To be clear, Callimachus is not a database — it talks to persistent stores via SPARQL among other protocols. The apps created using Callimachus are simple to use -- they look feel like a wiki. If you can fill out a web form or use a wiki, you can use a Callimachus app. Our team routinely combines public private datasources that are extracts of RDBMS (as CSV usually), and RDF to publish hundreds of millions of nicely styled pages (using Bootstrap3). Callimachus supports all kinds of nice transformations using pipelines, active PURLs, etc. For your needs, check out a basic Callimachus app that combines several public data sources, allows for crowdsourcing and includes content from US open gov’t sites, Wikipedia (DBpedia), Open Corporates and Open Street Maps. See the public Orgpedia pilot, an open organizational data project funded by the Sloan Foundation. Orgpedia is a free, not for profit online directory using open data about US, international, public private companies.[3] This app shows ownership of US based nuclear power plants, driven by some open datasets from the US EPA, Nuclear Regulatory Commission and SEC. I think your question involves crowdsourcing — you can see how we handled crowdsourcing, starting with authenticating using a FB, Google, Yahoo! or Callimachus account. A user can add images, link to Wikipedia articles or make corrections to existing data using a familiar Web form.[4] Have a look email the Callimachus public list if you have any questions.[5] All the best. Cheers, Bernadette Hyland http://about.me/bernadettehyland --- [1] http://callimachusproject.org/ http://callimachusproject.org/ [2] https://github.com/3-Round-Stones/callimachus https://github.com/3-Round-Stones/callimachus [3] http://orgpedia.callimachus.net http://orgpedia.callimachus.net/ [4] http://orgpedia.callimachus.net/nuclear/schema/how-to-contribute.xhtml?view http://orgpedia.callimachus.net/nuclear/schema/how-to-contribute.xhtml?view [5] https://groups.google.com/forum/#!forum/callimachus-discuss https://groups.google.com/forum/#!forum/callimachus-discuss On Feb 18, 2015, at 3:08 PM, Paul Houle ontolo...@gmail.com wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com mailto:ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup http://legalentityidentifier.info/lei/lookup
Re: Microsoft Access for RDF?
No, this is dangerous and is hiding the truth. Take the red pill and admit to the user that this particular property is unordered, for instance by always listing the values sorted (consistency is still king). Then make it easy to do lists and collections. Don't let the user encode information he considers important in a way that is not preserved semantically. If you are limited by typing of rdf:List elements, then look at owl approaches for collections that allow you to order items and use owl reasoning for list membership - see https://code.google.com/p/collections-ontology/ Ordering of which properties to show in which order on a form is another matter, that is a presentational view over the model. The :View could simply be a choice of an owl:Class and a partial order of owl:Properties instances of that class should have.
Re: Microsoft Access for RDF?
Yes, RDF 1.1 allows blank nodes to be shared across named graphs in a single dataset - obviously programmatically you have to be careful about how you achieve this. From http://www.w3.org/TR/rdf11-concepts/#section-dataset : Blank nodes can be shared between graphs in an RDF dataset. There's also nothing preventing an application from having union graphs which hides the named graphs - this is commonly available in many triple store. You can in theory also generate virtual graphs which are merging just a selection of named graphs in a dataset. Combining named graphs with an annotation model like W3C Web Annotation Model http://www.w3.org/TR/annotation-model/ or the nanopublications http://www.nanopub.org/guidelines/ means you can get scoping of the triples and an easy way to attach metadata about who made those triples, without needing to duplicate the information using reification (which could easily become disentangled from the true triples) On 19 February 2015 at 09:52, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel -- Stian Soiland-Reyes, eScience Lab School of Computer Science The University of Manchester http://soiland-reyes.com/stian/work/http://orcid.org/-0001-9842-9718
Re: Microsoft Access for RDF?
Hello, On 19 févr. 2015, at 11:31, Uldis Bojars capts...@gmail.com wrote: It would make sense to define UI element order at a higher level than individual triples. Defining the position for every triple separately would lead to chaos. A more sensible approach 'd be to define the order of statements [about something] at the property level. E.g. display the most important properties first, then have an ordered list of other properties that we know are frequently used for this type of objects and, as fallback, list all other (unknown) properties at the end. The Fresnel RDF vocabulary was designed to let you specify this sort of things. It lets you specify different “lenses” that apply to specific types of RDF resources (e.g. those that are instances of a given class, or those that match a particular SPARQL query) and then gives the RDF browse that applies a lens to a resource indications about which properties should be displayed, in what order, what properties can be used as fallbacks for others, etc. Plus some high-level indication about how property values should be formatted. [1] http://www.w3.org/2005/04/fresnel-info/ [2] http://dx.doi.org/10.1007/11926078_12 (ISWC paper) -- Emmanuel Pietriga INRIA INRIA Chile http://pages.saclay.inria.fr/emmanuel.pietriga
Re: Microsoft Access for RDF?
Hello Uldis, On Thu, Feb 19, 2015 at 12:31:40PM +0200, Uldis Bojars wrote: It would make sense to define UI element order at a higher level than individual triples. Defining the position for every triple separately would lead to chaos. A more sensible approach 'd be to define the order of statements [about something] at the property level. E.g. display the most important properties first, then have an ordered list of other properties that we know are frequently used for this type of objects and, as fallback, list all other (unknown) properties at the end. This is the first case i described: A predefined ordering. If the user introduces a new property or a new object, the position will not be clear. Regards, Michael Brunnbauer -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgp2To91ppde5.pgp Description: PGP signature
Re: Microsoft Access for RDF?
Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B München) ++ USt-IdNr. DE221033342 ++ Geschäftsführer: Michael Brunnbauer, Franz Brunnbauer ++ Prokurist: Dipl. Kfm. (Univ.) Markus Hendel pgpJDBJuWCbLV.pgp Description: PGP signature
Re: Microsoft Access for RDF?
Graham Klyne's Annalist is perhaps not quite what you are thinking of (I don't think it can connect to an arbitrary SPARQL endpoint), but I would consider it as falling under a similar category, as you have a user interface to define record types and forms, browse and edit records, with views defined for different record types. Under the surface it is however all RDF and REST - so you are making a schema by stealth. http://annalist.net/ http://demo.annalist.net/ On 18 February 2015 at 20:08, Paul Houle ontolo...@gmail.com wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- Stian Soiland-Reyes, eScience Lab School of Computer Science The University of Manchester http://soiland-reyes.com/stian/work/http://orcid.org/-0001-9842-9718
Re: Microsoft Access for RDF?
On 19 February 2015 at 11:52, Michael Brunnbauer bru...@netestate.de wrote: an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). It would make sense to define UI element order at a higher level than individual triples. Defining the position for every triple separately would lead to chaos. A more sensible approach 'd be to define the order of statements [about something] at the property level. E.g. display the most important properties first, then have an ordered list of other properties that we know are frequently used for this type of objects and, as fallback, list all other (unknown) properties at the end. Uldis
Re: Microsoft Access for RDF?
On 2/19/15 4:52 AM, Michael Brunnbauer wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Not really, in regards to Semantic Web expert starting to disagree per se. You can order by Predicate or use Reification. When designing our RDF Editor, we took the route of breaking things down as follows: Book (Named Graph Collection e.g. in a Quad Store or service that understands LDP Containers etc..) -- (contains) -- Pages (Named Graphs) -- Paragraphs (RDF Sentence/Statement Collections). The Sentence/Statement Collections are the key item, you are honing into, and yes, it boils down to: 1. Grouping sentences/statements by predicate per named graph to create a paragraph 2. Grouping sentences by way of reification where each sentence is identified and described per named graph. Rather that pit one approach against the other, we simply adopted both, as options. Anyway, you raise a very important point that's generally overlooked. Ignoring this fundamental point is a shortcut to hell for any editor that's to be used in a multi-user setup, as you clearly understand :) Kingsley Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
On 2/19/15 10:32 AM, Michael Brunnbauer wrote: Hello Paul, let me put this into two simple statements: 1) There is no canonical ordering of triples 2) A good triple editor should reflect this by letting the user determine the order Regards, Michael Brunnbauer Yes! Kingsley On Thu, Feb 19, 2015 at 03:50:33PM +0100, Michael Brunnbauer wrote: Hello Paul, I am not so sure if this is good enough. If you add something to the end of a list in a UI, you normally expect it to stay there. If you accept that it will be put in its proper position later, you may - as user - still have trouble figuring out where that position is (even with the heuristics you gave). The problem repeats with the triple object if the properties have been ordered. As user, you might feel even more compelled to introduce a deviant ordering on this level. Regards, Michael Brunnbauer On Thu, Feb 19, 2015 at 09:07:37AM -0500, Paul Houle wrote: There are quite a few simple heuristics that will give good enough results, consider for instance: (1) order predicates by alphabetical order (by rdfs:label or by localname or the whole URL) (2) order predicates by some numerical property given by a custom predicate in the schema (3) order predicates by the type of the domain alphabetically, and then order by the name of the predicates (4) work out the partial ordering of types by inheritance so Person winds up at the top and Actor shows up below that Freebase does something like (4) and that is good enough. On Thu, Feb 19, 2015 at 8:01 AM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/19/15 4:52 AM, Michael Brunnbauer wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Not really, in regards to Semantic Web expert starting to disagree per se. You can order by Predicate or use Reification. When designing our RDF Editor, we took the route of breaking things down as follows: Book (Named Graph Collection e.g. in a Quad Store or service that understands LDP Containers etc..) -- (contains) -- Pages (Named Graphs) -- Paragraphs (RDF Sentence/Statement Collections). The Sentence/Statement Collections are the key item, you are honing into, and yes, it boils down to: 1. Grouping sentences/statements by predicate per named graph to create a paragraph 2. Grouping sentences by way of reification where each sentence is identified and described per named graph. Rather that pit one approach against the other, we simply adopted both, as options. Anyway, you raise a very important point that's generally overlooked. Ignoring this fundamental point is a shortcut to hell for any editor that's to be used in a multi-user setup, as you clearly understand :) Kingsley Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++
Re: Microsoft Access for RDF?
Hi Paul, maybe I'm wrong, but I think what you are generally looking for (in the Semantic Web world) is the things that are going on at RDF Shapes group [1], or (but I guess you are aware of them)? What they can't do (yet; afaik) is the family instance loop check, or? On 2/18/2015 11:59 PM, Paul Houle wrote: For small projects you don't need access controls, provenance and that kind of thing, but if you were trying to run something like Freebase and Wikidata where you know what the algebra is the obvious thing to do is use RDF* and SPARQL*. No, why? - Wikidata's data model goes beyond RDF (triple based statements) for good reason. I'm always wondering why the heck we true Semantic Web developer still insist so hard on our beloved RDF (which all its drawbacks). Look forward. Think property graph and graph databases in general ;) You can also combine both perfectly, see, e.g., this graph data model [3] - RDF compatible, but able to store qualified attributes (e.g. order or provenance) at statement basis (without reification et. al). Re. editing of graph information, you may have a look at OrientDB's graph editor [4], which offers neat editing options direct in the graph (yay!). Cheers, Bo [1] http://www.w3.org/2014/data-shapes/wiki/Main_Page [2] http://en.wikipedia.org/wiki/Graph_database [3] https://github.com/dswarm/dswarm-documentation/wiki/Graph-Data-Model [4] http://www.orientechnologies.com/docs/2.0/orientdb-studio.wiki/Graph-Editor.html
Re: Microsoft Access for RDF?
On 2/19/15 4:08 PM, Stian Soiland-Reyes wrote: No, this is dangerous and is hiding the truth. What? Take the red pill and admit to the user that this particular property is unordered, for instance by always listing the values sorted (consistency is still king). A Predicate is a sentence forming Relation. Thus, you can effectively group RDF relations by Predicate scoped to a Named Graph IRI, if you choose. Naturally, you can also apply other forms of ordering, en route to effect UI/UX. Then make it easy to do lists and collections. You can describe collections using RDF statements, I don't have any idea how what I am talking about implies collection exclusion. Don't let the user encode information he considers important in a way that is not preserved semantically. ?? If you are limited by typing of rdf:List elements, then look at owl approaches for collections that allow you to order items and use owl reasoning for list membership - see https://code.google.com/p/collections-ontology/ Why do you think we've built an RDF editor without factoring in OWL? Ordering of which properties to show in which order on a form is another matter, that is a presentational view over the model. Sorta. The :View could simply be a choice of an owl:Class and a partial order of owl:Properties instances of that class should have. There is no perfect view. You simply need a view to enables: 1. coherent data curation 2. provides the user with choices in regards to how items are categorized. I think we are better off waiting until we release our RDF Editor. We actually built this on the request of a vary large customer. This isn't a speculative endeavor. It's actually being used by said organization as I type We've opted (we didn't have to) to make it Open Source too. -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
Hi Paul, Thanks for the detailed answer. There is human culture, and language, etc.. All in all we are a complicated species, but somehow, at whatever Latitude we are, snow, rain, heat, gloom of night, etc. we maintain an average internal body temperature of about 37 Centigrade (98.6 F). Humans all have this property, and we are the only animals with gadgets that locate us in time and space. We wander around in an isotropic fashion like Englishmen without dogs. It is not Brownian Motion, one can chart seasonal variation in location ... after all we might be Australians without dogs. Here are the charts. The variation over a year's time compared with tropical variation (tropics 45 Degrees N and -45 Degrees South) is tiny, tiny, tiny ( 13 arc minutes). http://www.rustprivacy.org/2015/locating-humans-with-gadgets.pdf Gadgets wildly over exaggerate their judgement as to our true location over time. The commercial world desperately wants to believe they know something important and Linked Open Data cannot stop their believing. We can, however make sure we don't feed the beast. It won't hurt RDF or Semantics a bit. Stian said, and I would agree: No, this is dangerous and is hiding the truth. Take the red pill and admit to the user that this particular property is unordered, for instance by always listing the values sorted (consistency is still king). --Gannon On Wed, 2/18/15, Paul Houle ontolo...@gmail.com wrote: Subject: Re: Microsoft Access for RDF? To: Gannon Dick gannon_d...@yahoo.com Cc: Linked Data community public-lod@w3.org Date: Wednesday, February 18, 2015, 6:10 PM Yes, there is the general project of capturing 100% of critical information in documents and that is a wider problem than the large amount of Linked Data which is basically RelationalDatabase++. Note that a lot of data in this world is in spreadsheets (like relational tables but often less discipline) and in formats like XML and JSON that are object-relational in the sense that a column can contain either a list or set of rows. Even before we tackle the problem of representing the meaning of written language (particularly when it comes to policies, standards documents, regulations, etc. as opposed to Finnegan's Wake or Mary had a little lamb) there is the slightly easier problem of understanding all the semi-structured data out there. Frankly I think the Bible gets things all wrong at the very beginning with In the beginning there was the word... because in the beginning we were animals and then we developed the language instinct, which is probably a derangement in our ability to reason about uncertainty which reduces the sample space for learning grammar. Often people suggest that animals are morally inferior to humans and I think the bible has a point where in some level we screw it up, because animals don't do the destructive behaviors that seem so characteristic of our species and that are often tied up with our ability to use language to construct contafactuals such as the very idea that there is some book that has all the answers because once somebody does that, somebody else can write a different book and say the same thing and then bam your are living after the postmodern heat death, even a few thousand years before the greeks. (Put simply: you will find that horses, goats, cows, dogs, cats and other domesticated animals consistently express pleasure when you come to feed them, which reinforces their feeding. A human child might bitch that they aren't getting what they want, which does not reinforce parental feeding behavior. Call it moral or social reasoning or whatever but when it comes to maximizing one's utility function, animals do a good job of it. The only reason I'm afraid to help an injured raccoon is that it might have rabies.) Maybe the logical problems you get as you try to model language have something to do with human nature, but the language instinct is a peripheral of an animal and it can't be modeled without modeling the animal. There is a huge literature of first order logic, temporal logic, modal logic and other systems that capture more of what is in language and the question of what comes after RDF is interesting; the ISO Common Logic idea that we go back to the predicate calculus and just let people make statements with arity 2 in a way that expands RDF is great, but we really need ISO Common Logic* based on what we know now. Also there is no conceptual problem in introducing arity 2 in SPARQL so we should just do it -- why convert relational database tables to triples and add the complexity when we can just treat them as tuples under the SPARQL algebra? Anyway there is a big way to go in this direction and I have thought about it deeply because I have stared into the commercialization valley of death for so long, but I think an RDF
Re: Microsoft Access for RDF?
I think you're particular concerned about the ordering of triples where ?s and ?p are the same? ?s ?p ?o1 , ?o2, ?o3, ?o4 . right? Sometimes people don't care, sometimes they do. One scenario is we are drawing a page about the creative works of Issac Asimov, the Kinks, or Jeff Bridges and want to see titles that everybody recognizes at the top of the list. In some of these cases there is a subjective element in that there is no global total ordering or even a partial ordering (see Arrow's Theorem), but it's fair to say more people know the song Lola than Ducks on the Wall. With RDF* you can put on edge weights which will support cases like that. Another approach is to further specify the data model so you get behavior like hashtables in PHP -- PHP hashtables support random access look up but if you iterate over them things come out in the order you put them in. Another case is where there really is a total ordering. For instance, the authors of a scientific paper might get excited if you list them in the wrong order. One weird old trick for this is RDF containers, which are specified in the XMP dialect of Dublin Core where you write something like [ dcterms:creator (Ralph Alpher,Hans Bethe,George Gamow) . ] In their version you are using text and not some authority record but if you just want to annotate the average business document it works. So yeah, I agree that ordering is a big issue in RDF; you are coming from it as a requirement for the editor, I see it as important if we want to use RDF technology as a universal solvent for dealing with all the JSON, XML and equivalently expressive documents and messages which support ordered collection. It's definitely a tooling issue but it does involve looking at hard issues in the underlying data model. On Thu, Feb 19, 2015 at 10:32 AM, Michael Brunnbauer bru...@netestate.de wrote: Hello Paul, let me put this into two simple statements: 1) There is no canonical ordering of triples 2) A good triple editor should reflect this by letting the user determine the order Regards, Michael Brunnbauer On Thu, Feb 19, 2015 at 03:50:33PM +0100, Michael Brunnbauer wrote: Hello Paul, I am not so sure if this is good enough. If you add something to the end of a list in a UI, you normally expect it to stay there. If you accept that it will be put in its proper position later, you may - as user - still have trouble figuring out where that position is (even with the heuristics you gave). The problem repeats with the triple object if the properties have been ordered. As user, you might feel even more compelled to introduce a deviant ordering on this level. Regards, Michael Brunnbauer On Thu, Feb 19, 2015 at 09:07:37AM -0500, Paul Houle wrote: There are quite a few simple heuristics that will give good enough results, consider for instance: (1) order predicates by alphabetical order (by rdfs:label or by localname or the whole URL) (2) order predicates by some numerical property given by a custom predicate in the schema (3) order predicates by the type of the domain alphabetically, and then order by the name of the predicates (4) work out the partial ordering of types by inheritance so Person winds up at the top and Actor shows up below that Freebase does something like (4) and that is good enough. On Thu, Feb 19, 2015 at 8:01 AM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/19/15 4:52 AM, Michael Brunnbauer wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Not really, in regards to Semantic Web expert starting to disagree per se. You can order by Predicate or use Reification. When designing our RDF Editor, we took the route of breaking things down as follows: Book (Named Graph Collection e.g. in a Quad Store or service that understands LDP Containers etc..) -- (contains) -- Pages (Named Graphs) -- Paragraphs (RDF Sentence/Statement Collections). The Sentence/Statement Collections are the key item, you are honing into, and yes, it boils down to: 1. Grouping sentences/statements by predicate per named graph to create a paragraph 2. Grouping sentences by way of reification where each sentence is identified and described per named graph. Rather that pit one approach against the other, we simply adopted both, as options. Anyway, you raise a very
Re: Microsoft Access for RDF?
There are quite a few simple heuristics that will give good enough results, consider for instance: (1) order predicates by alphabetical order (by rdfs:label or by localname or the whole URL) (2) order predicates by some numerical property given by a custom predicate in the schema (3) order predicates by the type of the domain alphabetically, and then order by the name of the predicates (4) work out the partial ordering of types by inheritance so Person winds up at the top and Actor shows up below that Freebase does something like (4) and that is good enough. On Thu, Feb 19, 2015 at 8:01 AM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/19/15 4:52 AM, Michael Brunnbauer wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Not really, in regards to Semantic Web expert starting to disagree per se. You can order by Predicate or use Reification. When designing our RDF Editor, we took the route of breaking things down as follows: Book (Named Graph Collection e.g. in a Quad Store or service that understands LDP Containers etc..) -- (contains) -- Pages (Named Graphs) -- Paragraphs (RDF Sentence/Statement Collections). The Sentence/Statement Collections are the key item, you are honing into, and yes, it boils down to: 1. Grouping sentences/statements by predicate per named graph to create a paragraph 2. Grouping sentences by way of reification where each sentence is identified and described per named graph. Rather that pit one approach against the other, we simply adopted both, as options. Anyway, you raise a very important point that's generally overlooked. Ignoring this fundamental point is a shortcut to hell for any editor that's to be used in a multi-user setup, as you clearly understand :) Kingsley Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup
Re: Microsoft Access for RDF?
Hello Paul, I am not so sure if this is good enough. If you add something to the end of a list in a UI, you normally expect it to stay there. If you accept that it will be put in its proper position later, you may - as user - still have trouble figuring out where that position is (even with the heuristics you gave). The problem repeats with the triple object if the properties have been ordered. As user, you might feel even more compelled to introduce a deviant ordering on this level. Regards, Michael Brunnbauer On Thu, Feb 19, 2015 at 09:07:37AM -0500, Paul Houle wrote: There are quite a few simple heuristics that will give good enough results, consider for instance: (1) order predicates by alphabetical order (by rdfs:label or by localname or the whole URL) (2) order predicates by some numerical property given by a custom predicate in the schema (3) order predicates by the type of the domain alphabetically, and then order by the name of the predicates (4) work out the partial ordering of types by inheritance so Person winds up at the top and Actor shows up below that Freebase does something like (4) and that is good enough. On Thu, Feb 19, 2015 at 8:01 AM, Kingsley Idehen kide...@openlinksw.com wrote: On 2/19/15 4:52 AM, Michael Brunnbauer wrote: Hello Paul, an interesting aspect of such a system is the ordering of triples - even if you restrict editing to one subject. Either the order is predefined and the user will have to search for his new triple after doing an insert or the user determines the position of his new triple. In the latter case, the app developer will want to use something like reification - at least internally. This is the point when the app developer and the Semantic Web expert start to disagree ;-) Not really, in regards to Semantic Web expert starting to disagree per se. You can order by Predicate or use Reification. When designing our RDF Editor, we took the route of breaking things down as follows: Book (Named Graph Collection e.g. in a Quad Store or service that understands LDP Containers etc..) -- (contains) -- Pages (Named Graphs) -- Paragraphs (RDF Sentence/Statement Collections). The Sentence/Statement Collections are the key item, you are honing into, and yes, it boils down to: 1. Grouping sentences/statements by predicate per named graph to create a paragraph 2. Grouping sentences by way of reification where each sentence is identified and described per named graph. Rather that pit one approach against the other, we simply adopted both, as options. Anyway, you raise a very important point that's generally overlooked. Ignoring this fundamental point is a shortcut to hell for any editor that's to be used in a multi-user setup, as you clearly understand :) Kingsley Maybe they can compromise on a system with a separate named graph per triple (BTW what is the status of blank nodes shared between named graphs?). Regards, Michael Brunnbauer On Wed, Feb 18, 2015 at 03:08:33PM -0500, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup -- ++ Michael Brunnbauer ++ netEstate GmbH ++ Geisenhausener Straße 11a ++ 81379 München ++ Tel +49 89 32 19 77 80 ++ Fax +49 89 32 19 77 89 ++ E-Mail bru...@netestate.de ++ http://www.netestate.de/ ++ ++ Sitz: München, HRB Nr.142452 (Handelsregister B
Re: Microsoft Access for RDF?
On 2/18/15 3:08 PM, Paul Houle wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? Sorta. We will soon release (this month or early March at the latest) a Read-Write Editor for RDF, in Open Source form, that addresses some of these features. Naturally, it supports WebID, LDP, WebACL etc.. -- Regards, Kingsley Idehen Founder CEO OpenLink Software Company Web: http://www.openlinksw.com Personal Weblog 1: http://kidehen.blogspot.com Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen Twitter Profile: https://twitter.com/kidehen Google+ Profile: https://plus.google.com/+KingsleyIdehen/about LinkedIn Profile: http://www.linkedin.com/in/kidehen Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this smime.p7s Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
Hey Paul, we have the editing interface, but ontologies are not of much help here. The question is, how and where to draw the boundary of the description that you want to edit, because millions of triples on one page will not work. Fine-grained named graphs and/or SPARQL queries/updates are 2 solutions for this. Martynas graphityhq.com On Wed, Feb 18, 2015 at 9:08 PM, Paul Houle ontolo...@gmail.com wrote: I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup
Microsoft Access for RDF?
I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254paul.houle on Skype ontolo...@gmail.com http://legalentityidentifier.info/lei/lookup
Re: Microsoft Access for RDF?
Why do you assume I assume something?
I simply stated what should be considered. When Paul replies, we'll
know what kind of dataset it is, and whether these issues apply.
He mentions DBPedia as an example, which returns around 20 named
graphs for triples. How are those supposed to be edited?
select distinct ?g where { graph ?g { ?s ?p ?o } }
count() didn't work for me BTW.
On Wed, Feb 18, 2015 at 10:51 PM, Kingsley Idehen
kide...@openlinksw.com wrote:
On 2/18/15 4:01 PM, Martynas Jusevičius wrote:
we have the editing interface, but ontologies are not of much help
here. The question is, how and where to draw the boundary of the
description that you want to edit, because millions of triples on one
page will not work.
Why do you assume that the target of an edit is a massive dataset presented
in a single page?
--
Regards,
Kingsley Idehen
Founder CEO
OpenLink Software
Company Web: http://www.openlinksw.com
Personal Weblog 1: http://kidehen.blogspot.com
Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen
Twitter Profile: https://twitter.com/kidehen
Google+ Profile: https://plus.google.com/+KingsleyIdehen/about
LinkedIn Profile: http://www.linkedin.com/in/kidehen
Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
Re: Microsoft Access for RDF?
On 2/18/15 5:07 PM, Martynas Jusevičius wrote:
Why do you assume I assume something?
Because he spoke about an Microsoft-Access-like solution. If you've used
that tool you would know that massive dataset edits, as you indicated,
can't be the focal point of his quest, hence my comment.
I simply stated what should be considered. When Paul replies, we'll
know what kind of dataset it is, and whether these issues apply.
See my comment above.
He mentions DBPedia as an example, which returns around 20 named
graphs for triples. How are those supposed to be edited?
He can (if he needs to) scope his activity to triples associated with a
specific named graph.
select distinct ?g where { graph ?g { ?s ?p ?o } }
count()
didn't work for me BTW.
Yes, that's by design [1].
[1] http://lists.w3.org/Archives/Public/public-lod/2011Aug/0028.html --
DBpedia fair use policy .
Kingsley
On Wed, Feb 18, 2015 at 10:51 PM, Kingsley Idehen
kide...@openlinksw.com wrote:
On 2/18/15 4:01 PM, Martynas Jusevičius wrote:
we have the editing interface, but ontologies are not of much help
here. The question is, how and where to draw the boundary of the
description that you want to edit, because millions of triples on one
page will not work.
Why do you assume that the target of an edit is a massive dataset presented
in a single page?
--
Regards,
Kingsley Idehen
Founder CEO
OpenLink Software
Company Web: http://www.openlinksw.com
Personal Weblog 1: http://kidehen.blogspot.com
Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen
Twitter Profile: https://twitter.com/kidehen
Google+ Profile: https://plus.google.com/+KingsleyIdehen/about
LinkedIn Profile: http://www.linkedin.com/in/kidehen
Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
--
Regards,
Kingsley Idehen
Founder CEO
OpenLink Software
Company Web: http://www.openlinksw.com
Personal Weblog 1: http://kidehen.blogspot.com
Personal Weblog 2: http://www.openlinksw.com/blog/~kidehen
Twitter Profile: https://twitter.com/kidehen
Google+ Profile: https://plus.google.com/+KingsleyIdehen/about
LinkedIn Profile: http://www.linkedin.com/in/kidehen
Personal WebID: http://kingsley.idehen.net/dataspace/person/kidehen#this
smime.p7s
Description: S/MIME Cryptographic Signature
Re: Microsoft Access for RDF?
Well here is my user story. I am looking at a page that looks like this http://dbpedia.org/page/Albert_Einstein it drives me up the wall that the following facts are in there: :Albert_Einstein dbpedia-owl:childOf :EinsteinFamily ; dbpedia-owl:parentOf :EinsteinFamily . which is just awful in a whole lot of ways. Case (1) is that I click an X next to those two triples and they are gone, Case (2) is that I can create new records to fill in his Family tree and that will involve many other user stories such as (3) user creates literal field and so forth. Freebase and Wikidata have good enough user interfaces that revolve around entities, see https://www.freebase.com/m/0jcx (while you still can) http://www.wikidata.org/wiki/Q937 but neither of those is RDF-centric. It seems to me that an alternative semantics could be defined for RDF and OWL that work work like so: * we say :Albert_Einstein is a :Person * we then see some form with fields people can fill, or alternately there is a dropdown list with predicates that have this as a known domain; the range can also be used backwards so that we expect a langstring or integer or link to another :Person It's important that this be some tool that somebody who knows little about RDF can enter data and edit it with a little bit of task-oriented (as opposed to concept-oriented training.) The idea here is that the structures and vocabulary are constrained so that the structures are not complex; both DBpedia and Freebase are so constrained. You might want to say things like [ a sp:Ask ; rdfs:comment must be at least 18 years old^^xsd:string ; sp:where ([ sp:object sp:_age ; sp:predicate my:age ; sp:subject spin:_this ] [ a sp:Filter ; sp:expression [ sp:arg1 sp:_age ; sp:arg2 18 ; a sp:lt ] ]) ] and that is cool, but I have no idea how to make that simple for a muggle to use and I'm interested in these things that are similar in character to a relational database, so I'd say that is out-of-scope for now. I think this tool could probably edit RDFS schemas (treating them as instance data) but not be able to edit OWL schemas (if you need that use an OWL editor) Now if I was really trying to construct family trees I'd have to address cycles like that with some algorithms and heuristics because it probably take a long time to pluck them out by hand, but some things you'll want to edit by hand and that process will be easier if you are working with a smaller data set, which you can easily find. If you have decent type data, as does Freebase, it is not hard to pick out pieces of the WikiWorld, such as ski areas or navy ships and the project of improving that kind of database with hand tools is much more tractable. For small projects you don't need access controls, provenance and that kind of thing, but if you were trying to run something like Freebase and Wikidata where you know what the algebra is the obvious thing to do is use RDF* and SPARQL*.
Re: Microsoft Access for RDF?
Paul, does this look something like the interface you could use? http://linkeddatahub.com/ldh?mode=http%3A%2F%2Fgraphity.org%2Fgc%23EditMode Martynas graphityhq.com On Wed, Feb 18, 2015 at 11:59 PM, Paul Houle ontolo...@gmail.com wrote: Well here is my user story. I am looking at a page that looks like this http://dbpedia.org/page/Albert_Einstein it drives me up the wall that the following facts are in there: :Albert_Einstein dbpedia-owl:childOf :EinsteinFamily ; dbpedia-owl:parentOf :EinsteinFamily . which is just awful in a whole lot of ways. Case (1) is that I click an X next to those two triples and they are gone, Case (2) is that I can create new records to fill in his Family tree and that will involve many other user stories such as (3) user creates literal field and so forth. Freebase and Wikidata have good enough user interfaces that revolve around entities, see https://www.freebase.com/m/0jcx (while you still can) http://www.wikidata.org/wiki/Q937 but neither of those is RDF-centric. It seems to me that an alternative semantics could be defined for RDF and OWL that work work like so: * we say :Albert_Einstein is a :Person * we then see some form with fields people can fill, or alternately there is a dropdown list with predicates that have this as a known domain; the range can also be used backwards so that we expect a langstring or integer or link to another :Person It's important that this be some tool that somebody who knows little about RDF can enter data and edit it with a little bit of task-oriented (as opposed to concept-oriented training.) The idea here is that the structures and vocabulary are constrained so that the structures are not complex; both DBpedia and Freebase are so constrained. You might want to say things like [ a sp:Ask ; rdfs:comment must be at least 18 years old^^xsd:string ; sp:where ([ sp:object sp:_age ; sp:predicate my:age ; sp:subject spin:_this ] [ a sp:Filter ; sp:expression [ sp:arg1 sp:_age ; sp:arg2 18 ; a sp:lt ] ]) ] and that is cool, but I have no idea how to make that simple for a muggle to use and I'm interested in these things that are similar in character to a relational database, so I'd say that is out-of-scope for now. I think this tool could probably edit RDFS schemas (treating them as instance data) but not be able to edit OWL schemas (if you need that use an OWL editor) Now if I was really trying to construct family trees I'd have to address cycles like that with some algorithms and heuristics because it probably take a long time to pluck them out by hand, but some things you'll want to edit by hand and that process will be easier if you are working with a smaller data set, which you can easily find. If you have decent type data, as does Freebase, it is not hard to pick out pieces of the WikiWorld, such as ski areas or navy ships and the project of improving that kind of database with hand tools is much more tractable. For small projects you don't need access controls, provenance and that kind of thing, but if you were trying to run something like Freebase and Wikidata where you know what the algebra is the obvious thing to do is use RDF* and SPARQL*.
Re: Microsoft Access for RDF?
Hi Paul, I'm detecting a snippy disturbance in the Linked Open Data Force :) The text edit problem resides in the nature of SQL type queries vs. SPARQL type queries. It's not in the data exactly, but rather in the processing (name:value pairs). To obtain RDF from data in columns you want to do a parity shift rather than a polarity shift. Given the statement: Mad Dogs and Englishmen go out in the midday sun (parity shift) Australians are Down Under Englishmen and just as crazy. (polarity shift) Australians are negative Englishmen, differently crazy. Mad Dogs ? Well, that's another Subject. The point is, editing triples is not really any easier than editing columns, but it sometimes looks dangerously easy. -Gannon [1] 'Air and water are good, and the people are devout enough, but the food is very bad,' Kim growled; 'and we walk as though we were mad--or English. It freezes at night, too.' -- Kim by Rudyard Kipling (Joseph Rudyard Kipling (1865-1936)), Chapter XIII, Copyright 1900,1901 On Wed, 2/18/15, Paul Houle ontolo...@gmail.com wrote: Subject: Microsoft Access for RDF? To: Linked Data community public-lod@w3.org Date: Wednesday, February 18, 2015, 2:08 PM I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps there are things like the compound value types from Freebase which are sorta like blank nodes but they have names, Sometimes I want to manually edit a few records. Perhaps I want to delete a triple or add a few triples (possibly introducing a new subject.) It seems to me there could be some kind of system which points at a SPARQL protocol endpoint (so I can keep my data in my favorite triple store) and given an RDFS or OWL schema, automatically generates the forms so I can easily edit the data. Is there something out there? -- Paul Houle Expert on Freebase, DBpedia, Hadoop and RDF (607) 539 6254 paul.houle on Skype ontology2@gmail.comhttp://legalentityidentifier.info/lei/lookup
Re: Microsoft Access for RDF?
Yes, there is the general project of capturing 100% of critical information in documents and that is a wider problem than the large amount of Linked Data which is basically RelationalDatabase++. Note that a lot of data in this world is in spreadsheets (like relational tables but often less discipline) and in formats like XML and JSON that are object-relational in the sense that a column can contain either a list or set of rows. Even before we tackle the problem of representing the meaning of written language (particularly when it comes to policies, standards documents, regulations, etc. as opposed to Finnegan's Wake or Mary had a little lamb) there is the slightly easier problem of understanding all the semi-structured data out there. Frankly I think the Bible gets things all wrong at the very beginning with In the beginning there was the word... because in the beginning we were animals and then we developed the language instinct, which is probably a derangement in our ability to reason about uncertainty which reduces the sample space for learning grammar. Often people suggest that animals are morally inferior to humans and I think the bible has a point where in some level we screw it up, because animals don't do the destructive behaviors that seem so characteristic of our species and that are often tied up with our ability to use language to construct contafactuals such as the very idea that there is some book that has all the answers because once somebody does that, somebody else can write a different book and say the same thing and then bam your are living after the postmodern heat death, even a few thousand years before the greeks. (Put simply: you will find that horses, goats, cows, dogs, cats and other domesticated animals consistently express pleasure when you come to feed them, which reinforces their feeding. A human child might bitch that they aren't getting what they want, which does not reinforce parental feeding behavior. Call it moral or social reasoning or whatever but when it comes to maximizing one's utility function, animals do a good job of it. The only reason I'm afraid to help an injured raccoon is that it might have rabies.) Maybe the logical problems you get as you try to model language have something to do with human nature, but the language instinct is a peripheral of an animal and it can't be modeled without modeling the animal. There is a huge literature of first order logic, temporal logic, modal logic and other systems that capture more of what is in language and the question of what comes after RDF is interesting; the ISO Common Logic idea that we go back to the predicate calculus and just let people make statements with arity 2 in a way that expands RDF is great, but we really need ISO Common Logic* based on what we know now. Also there is no conceptual problem in introducing arity 2 in SPARQL so we should just do it -- why convert relational database tables to triples and add the complexity when we can just treat them as tuples under the SPARQL algebra? Anyway there is a big way to go in this direction and I have thought about it deeply because I have stared into the commercialization valley of death for so long, but I think an RDF editor for Linked Data as we know it which is more animal in it's nature than human is tractable and useful and maybe a step towards the next thing. On Wed, Feb 18, 2015 at 6:28 PM, Gannon Dick gannon_d...@yahoo.com wrote: Hi Paul, I'm detecting a snippy disturbance in the Linked Open Data Force :) The text edit problem resides in the nature of SQL type queries vs. SPARQL type queries. It's not in the data exactly, but rather in the processing (name:value pairs). To obtain RDF from data in columns you want to do a parity shift rather than a polarity shift. Given the statement: Mad Dogs and Englishmen go out in the midday sun (parity shift) Australians are Down Under Englishmen and just as crazy. (polarity shift) Australians are negative Englishmen, differently crazy. Mad Dogs ? Well, that's another Subject. The point is, editing triples is not really any easier than editing columns, but it sometimes looks dangerously easy. -Gannon [1] 'Air and water are good, and the people are devout enough, but the food is very bad,' Kim growled; 'and we walk as though we were mad--or English. It freezes at night, too.' -- Kim by Rudyard Kipling (Joseph Rudyard Kipling (1865-1936)), Chapter XIII, Copyright 1900,1901 On Wed, 2/18/15, Paul Houle ontolo...@gmail.com wrote: Subject: Microsoft Access for RDF? To: Linked Data community public-lod@w3.org Date: Wednesday, February 18, 2015, 2:08 PM I am looking at some cases where I have databases that are similar to Dbpedia and Freebase in character, sometimes that big (ok, those particular databases), sometimes smaller. Right now there are no blank nodes, perhaps
