by

Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
  • May 27 2019 06:08
    User @Mitzi-Laszlo unbanned @in1t3r
  • May 23 2019 06:49
    @Mitzi-Laszlo banned @in1t3r
  • May 16 2019 09:49
    @Mitzi-Laszlo banned @mediaprophet
  • Feb 01 2019 22:04
    User @melvincarvalho unbanned @namedgraph_twitter
  • Feb 01 2019 21:49
    @melvincarvalho banned @namedgraph_twitter
Willem Wyndham
@willemneal
Yep I agree ;-) that's why I'm excited by it.
Mark Hughes (happybeing)
@theWebalyst
@dmitrizagidulin if you can find me (on my boat) I'll crack open a barrel from the stores :wink:
Dmitri Zagidulin
@dmitrizagidulin
@willemneal right on! :)
@theWebalyst ha! awesome. (I will have a /ton/ of questions, too, I'm super curious about canal boat liveaboards!)
Willem Wyndham
@willemneal
@dmitrizagidulin Just found a master thesis explaining how to do SPARQL with MapReduce.
Dmitri Zagidulin
@dmitrizagidulin
huh! interesting
Mark Hughes (happybeing)
@theWebalyst
@dmitrizagidulin Well, maybe we should get on a mumble chat or something. I'm happy to answer any questions.
Dmitri Zagidulin
@dmitrizagidulin
sure thing
Mark Hughes (happybeing)
@theWebalyst
I have to go now.. Thanks everyone for your input.
Dmitri Zagidulin
@dmitrizagidulin
hey @kjetilk, I don't suppose you're gonna be at the My Data Global conf later this month?
@theWebalyst see ya
Kjetil Kjernsmo
@kjetilk
@dmitrizagidulin I haven't planned anything
Helsinki isn't far away though
Dmitri Zagidulin
@dmitrizagidulin
@kjetilk i’ll be there. so, if yer in the area, lets meet up
Kjetil Kjernsmo
@kjetilk
Cool!
Yeah, Helsinki is pretty nice, I've been through Helsinki for racing now and then
Ghost
@ghost~57bc59d440f3a6eec060e93b
Tim Berners-Lee
@timbl
Of course the rdflib.js which we use does have a simple query engine (@dmitrizagidulin)which does graph matching, does not have built in math functions ect you need for sparql. It will look up linked data live as it queries linked data in the web. For example, one of the chat widgets in soli-ui takes a query object as a parameter, so you can fire it up for any ontology and graph shape you find out there.
Dmitri Zagidulin
@dmitrizagidulin
@timbl that.. sounds promising! how does one use it?
Mark Hughes (happybeing)
@theWebalyst
I'm all :ear:
Sarven Capadisli
@csarven
@theWebalyst Ultimately what matters is the RDF language. It resembles subject-verb-object pattern in human-languages ( see https://en.wikipedia.org/wiki/Linguistic_typology ). It is a machine-readable constructed language. The rest are details :P ... ok, IMHO the 'ideal' RDF format depends on the environment and the actors involved. All are intended to be dealt as a graph as opposed to the face value in the syntax. Having said that here is only a summary (the devil is in the details of course): N-Triples is fantastic given that it is as declarative as it gets. Friends with line-processing tools. In comparison to the other formats, relatively no surprises. Turtle being somewhat of a "short hand" is for a number of use cases (eg. writing / reading is simple - usually great for vocabs). JSON-LD for FWIW is simple to deal with in the Web browser. Again, not that it should be treated as plain JSON, but one can get away with browser's built-in know-how. That is, you can read-write an object at ease. Turtle would for example requires a dedicated library to handle it. RDFa in markup languages (HTML/SVG/MathML..) is pretty sweet in that you can use the same data (at same URL) for both humans and machines - no need to duplicate data or have hidden data islands, additional libraries, or multiple URLs... Like JSON-LD handling, RDFa in the DOM is easy to poke around out of the box. As for RDF/XML... we don't talk about that. :P It is not intended to be treated like XML (and there is a super mature toolchain and related standards around that), but one can get away with it fairly easily for non-super complex cases. All with the exception of RDFa in HTML (SVG/MathML..) for example has to find their way into the DOM (or some other rendering environment) to present information for "humans". IMO, there is no "one size fits all". There is a trend towards JSON-LD based standards (eg Web Annotation, Linked Data Notifications, ActivityPub..) because of some convenience with JS based environments. If I'm stuck in an island and need to send messages with bottles, I'd probably use N-Triples or HTML+RDFa.
Mark Hughes (happybeing)
@theWebalyst

Thanks @csarven that's helpful. One of my concerns with JSON-LD is that it might lead devs astray in terms of the value and use of RDF.

Firstly, assuming RDF tools and libraries are more relevant to RDF and Semantic Web applications than JSON-LD tools and libraries (since JSON-LD was built for other purposes and with Semantic Web 'not even a consideration', at least to begin with). So RDF tools would I think lead devs towards uses, models and communities that RDF targets, and would I anticipate encourage practices that support the Semantic Web, and the application independence and interoperability that is fundamental to Solid. Whereas use of JSON-LD libraries and tooling could in turn discourage those desirable things.

Secondly, even if those concerns are not shared, I am at least as concerned if devs try to create JSON-LD with or without a 'dedicated library' and JSON-LD specific tooling. JSON-LD is not necessarily conformant if I understand correctly, whereas one hopes at least that any Turtle, n3 (or other conformant representations) generated by a 'dedicated library' would generate a conformant representation. I don't know if one can even be sure that JSON-LD tools and libraries will produce conformant JSON-LD, presumably not. And if JSON-LD is generated without tools it is even more likely to contain RDF bugs. So I see the need for a dedicated library as helping devs get things right, and a non JSON-LD library as preferable to a JSON-LD library at that, for improving outcomes including interoperability.

I can see why people familiar with JSON in the browser would be attracted to JSON-LD, but am concerned if that attraction might be a siren voice leading the unwary away from what might serve them better in the long term. Those are my thoughts in two large nutshells, but I admit I don't know enough to be confident of those positions, so any corrections and comments on this would be helpful. Thanks for reading!

Tim Berners-Lee
@timbl
Well put, @theWebalyst
Tim Berners-Lee
@timbl
Several projects found to their cost that they started their devs off with RDF/XML and their devs then tried to use the XML part of thei r brain to look at the data. That could leave them two years behind. The use of XML in the first RDF format standardized was felt to be a logical thing, which would maybe help people understand RDF, and perhaps protect RDF from atttacks from XML people who saw it as a threat. It did neither, I think. I am worried, like @kjetilk, that JSON/LD may have the same problems down the line. People witll use JSON parts of their heads and their code to handle it, instead of graph parts.
@csarven you are right that it is about the language. That’s why when you make what people call a NamedNode in the RDF grpah, the rdflib function was $rdf.sym() as it generates a symbol in the language.
At the RDF level, there is an isomorphism between the graph and turtle. It is useful to use the mental tools we have both for thinking about graphs and thinking in a language, and turtle as the language works well.
( In fact but most of my coding day I am thinking in the language, and the language is strctly N3. For me N3 is a complete langauge, and turtle a useful subset which happens to map to graphs and which we use at the data interchange layer. But n3 I can use for more stuff, like rules, and it is nice to have one a smooth extension of the other. But most of the bulk of the stuff I read and write ends up as being in Turtle.)
I think it is valuable for developers working on things like Solid to be fluent in turtle. To be able to say things like :child a rdf:Property; s:label “child’; owl:inverse [ s:label “parent”]. (meaning “child is a property, whose label is “child” ,and which has an inverse whose label is “parent”) where I expect people to be happy reading the [ ] clauses as a core part of the langugage. Not having to draw a graoh with a bnode in on the whiteboard. We developped N3 first as a language for IRC chat and whiteboards where we wanted to be expressive and concise without having to draw circles and arrows. When you use turtle you are talking about things, not javascript objects. There is an important difference. Your thinking and your code should be about things: people, events, relationships. Not about symbols. Not about nodes. Not about objects.
That’s my take on this.
Ghost
@ghost~57bc59d440f3a6eec060e93b
So in effect, the decision making process is to us n3, and turtle as a subset of n3, rather than using something else...? I've seen a trend of JSON-LD being used for commercial integration projects, seeking to uplift traditional API services. Whereas the rww / webscience group (if that's a fair distinction to make) have always seemingly been set on turtle, but that might be better declared overall to be n3, due to reasons / insights that have been less clear overall... I had the opinion that most know how to deal with JSON-LD
Kingsley Idehen
@kidehen

@mediaprophet : What @timbl is saying is that he thinks and codes based on a realm comprising entities, entity types, entity relationships, and entity relationship types. He can even model for inferred entity relationship types (or even test their conceptual consistencies or inconsistencies) using N3 as a Rules Language.

For the rules part, you can also use SPARQL and terms from the SPIN or SHACL vocabs which enable it to function as a Rule Language too.

So the decision making boils down to using a language (or complimentary languages) that keep you rooted in a realm where entities are related to other entities in a variety of ways -- rather than being distracted by programming language symbols and the runtime objects they denote.

My rule of thumb: If you have to mention nodes, edges, and arcs in an attempt to describe an entity relationship type, the conversation is already completely broken, logically :)

Austin Wright
@awwright
I think that's a general Web problem. The core property of Web technology is the hyperlink, but lots of the time people are using tools to scrape data and generate URI & URLs, instead of using tools to enumerate links, already defined in some standard format (link/a tags in HTML, Link header in HTTP) and follow them
Tim Berners-Lee
@timbl
The semantic web has a lot of similarities to hypertext but it is not hypertext.
Tim Berners-Lee
@timbl
Html is Hypertext. RDF is semantic web, linked data. Hypertext involves links between anchors. Linked data involves relationships between things.
Eureka Chen
@EurekaChen
yes
Martynas Jusevicius
@namedgraph_twitter
@theWebalyst what makes sense to us "RDF people" apparently does not make sense to "mainstream developers". they don't want to hear about semantics, they want their JSON. so IMO it's better to have some kind of bridge to them, in the form of JSON-LD, rather than none
and very likely, by ignoring RDF and the Semantic Web, the developers are working against their own long-term interests
but i think it's human nature that makes it difficult to see beyond short-term
and it's similar with RDF/XML. it is not the most human-readable or best specified RDF syntax, but it does have its uses as a bridge to the XML ecosystem. which, as @csarven pointed out, has very powerful tools such as XSLT. you just need to know what you're doing
Martynas Jusevicius
@namedgraph_twitter
contrary to what many RDF people believe, a constrained RDF/XML profile can be successfully used for XSLT transformations (e.g. with XHTML as the output): https://www.w3.org/community/rax/wiki/Draft_Material#RDF.2FXML_.22plain.22_profile_suitable_for_XSLT_transformations
Martynas Jusevicius
@namedgraph_twitter
I think in large part browser vendors are to blame for abandoning declarative tech such as XSLT and pushing JavaScript exclusively. as a result, JSON became the leading format as it is native to JS. it is really it's only advantage over XML
Kingsley Idehen
@kidehen

@namedgraph_twitter regarding RDF-XML, the problem also became complicated by a combination of time and the general mindset around XML e.g., the notion that HTTP URIs didn't need to resolve which inadvertently lead to problems comprehending the utility of relative HTTP URIs that leverage "#" as an indexical.

In my experience, RDF-XML is a powerful notation for developing RDFizers (Transformers, Providers, Connectors) that emit 5-Star Linked Data.

Since 2007, we have developed close to 100 transformers for various APIs and Document Types using RDF-XML and XSLT. The key for us is keeping that in the box we call the Virtuoso Middleware Layer (a/k/a Sponger) i.e., users do not encounter RDF-XML at all, they simply enjoy the data wrangling and transformation benefits it provides :)

Martynas Jusevicius
@namedgraph_twitter
those notions are still coming back to bite today :) e.g. http:// URIs used in namespaces cannot be upgraded to https:// https://sourceforge.net/p/saxon/mailman/message/36381737/
RDF/XML 1.1 could have fixed some of the major issues, but i guess the interest wasn't there...
Kingsley Idehen
@kidehen

@namedgraph_twitter : All we can do (IMHO) is put our heads together and collaborate our way to a time and place where coherent use and understanding of what constitutes a Semantic Web permeates a majority of applications via the frameworks and libraries from which they are developed.

That would make things solid :)

Mark Hughes (happybeing)
@theWebalyst
@namedgraph_twitter and @kidehen this is very helpful to my understanding. Thanks. Keep it coming! :smile:
Sarven Capadisli
@csarven
@timbl We may agree and disagree to parts of this :) but I feel it is worth pointing out - to those that are interested in this topic - that while HTML without any embedded RDF is plain ol' Hypertext, with embedded RDF (RDFa, Turtle, JSON-LD, TriG, N-Quads) however, relationships between things can be expressed at the same granularity as Turtle, JSON-LD, .. alone. Language mixing makes that possible. For example, to the best of my knowledge, there is nothing in particular that can be expressed in Turtle but not in HTML+RDFa or vice-versa. Isomorphic strictly on the RDF language level. Plain HTML at best gets us relating documents, which is still a subset of relating things as I understand it. (Aside: links with fragments in hypertext documents at best points at nodes in documents, but that's no longer about RDF-y things.)
Sarven Capadisli
@csarven
To some extent it is valid (reasonable?) to have a hyperlink with a fragment referring to a local part of an external document in HTML (which doesn't have any embedded RDF.. so we're talking about just plain HTML), and to interpret that as a statement in RDF. (Aside: I can't recall how well this behaviour is described in specs, if at all.) It would just be a statement that's being made in the source document, and that's pretty much it. Following that link doesn't help us obtain more knowledge (using the RDF rules) about that object resource since there is nothing there to be found (based on RDF speak!) So, I generally agree with HTML alone is not "linked data" per se (or maybe even useful LD, if at all), but embedding syntaxes that are dedicated to express information using the RDF language brings HTML (as well as other languages that act as the host language to embed RDF eg. SVG, MathML) into the LD Web.
Sarven Capadisli
@csarven
To clarify the hyperlinking example: <a rel="license" href="https://creativecommons.org/licenses/by/4.0/">. An RDFa would probably return a statement along the lines of: <{baseURL}> xhv:license <https://creativecommons.org/licenses/by/4.0/>.
Sarven Capadisli
@csarven
s/An RDFa/An RDFa parser and Turtle serialiser
Ghost
@ghost~57bc59d440f3a6eec060e93b
@kidehen / @timbl my last note was an unsent draft, that appears to have sent for some reason. As you know, i've done a bit of work in the JSON-LD realm. What I didn't manage to author in that note (that wasn't Intended to be sent) was that n3 is a purpose built language, turtle is a subset.
There are nuances, that I've not been able to clearly describe to others. It seemed the easiest distinction to make, was to consider JSON-LD as a commercial upgrade path, or moreover an update path from json based APIs, et.al. anyhow, still trying to bring Into frame TimBLs earlier comments. ..
Kingsley Idehen
@kidehen

@mediaprophet : To cut a long story short re. JSON-LD:
In its current form, it doesn't handle relative HTTP URIs properly.

Here's a lengthy thread that concludes with a fix to this particular JSON-LD bug -- that's part of the next release: json-ld/json-ld.org#488

Ghost
@ghost~57bc59d440f3a6eec060e93b
@kidehen cheers... U know that "stuff" has been bugging me for years... Good to see the crew more cohesive nowadays. Still lots of work to be done though. I have a bit to catch up on tomorrow. Night.
Kingsley Idehen
@kidehen

@csarven re :point_up: August 13, 2018 11:12 AM, the issue is that HTML (Hypertext), RDF, Linked Data (Hyperdata or Linked Data [when Linked Data principles are applied to RDF]) are distinct languages targeting different problems.

Naturally, you can use raw HTML as the object of an RDF relation [1].

[1] https://tinyurl.com/y9tfd8av -- a live example

Likewise, you can inject RDF into a structured data island within an HTML document [2].

[2] https://www.uniprot.org/uniprot/P02741 -- a live example

Structured data islands within an HTML document doesn't immediately help users and developers to properly understand the fundamentals of a Semantic Web i.e., we don't reach that point of critical clarity required for making this stuff explode by way of serendipitous discovery and surreptitious content curation.

Personally, I believe dokie.li presents a powerful solution and opportunity (project wise) to address the important challenge outlined above. The critical todo is getting its binding to solid sorted out, which inevitably means getting solid's authentication sorted out, and as you can see we are heading into a strange loop++

Fundamentally, end-users should just enjoy the power of a Semantic Web while developers should be encouraged to write applications for the real-world that actually leverage real-world modeling rather than sticking to a broken fad-driven pattern that fixates on syntax and runtime object interaction [where said objects have no real-world semblance).