Chatlog 2010-03-11

From RDFa Working Group Wiki
Jump to: navigation, search

See CommonScribe Control Panel, original RRSAgent log and preview nicely formatted version.

14:17:19 <RRSAgent> RRSAgent has joined #rdfa
14:17:19 <RRSAgent> logging to
14:17:21 <trackbot> RRSAgent, make logs world
14:17:21 <Zakim> Zakim has joined #rdfa
14:17:23 <trackbot> Zakim, this will be 7332
14:17:23 <Zakim> ok, trackbot; I see SW_RDFa()10:00AM scheduled to start in 43 minutes
14:17:24 <trackbot> Meeting: RDFa Working Group Teleconference
14:17:24 <trackbot> Date: 11 March 2010
14:58:51 <Zakim> SW_RDFa()10:00AM has now started
14:58:53 <ShaneM> ShaneM has joined #rdfa
14:58:58 <Zakim> +ShaneM
14:59:11 <Steven> Steven has joined #rdfa
14:59:28 <Zakim> +[IPcaller]
14:59:33 <manu> zakim, I am [IP
14:59:33 <Zakim> ok, manu, I now associate you with [IPcaller]
14:59:54 <ivan> zakim, dial ivan-voip
14:59:54 <Zakim> ok, ivan; the call is being made
14:59:55 <Zakim> +Ivan
15:00:30 <Zakim> +Benjamin
15:01:20 <Zakim> +Knud
15:02:07 <Steven> zakim, dial steven-617
15:02:07 <Zakim> ok, Steven; the call is being made
15:02:09 <Zakim> +Steven
15:03:00 <Steven> zakim, who is noisy?
15:03:09 <tinkster> tinkster has joined #rdfa
15:03:11 <Zakim> Steven, listening for 10 seconds I heard sound from the following: ShaneM (62%), [IPcaller] (4%), Knud (27%), Ivan (4%), Steven (5%)
15:03:17 <Zakim> +tinkster
15:03:33 <Knud> zakim, mute me
15:03:33 <Zakim> Knud should now be muted
15:04:32 <Steven> Scribe: Steven
15:05:17 <Steven> Note that the call is one hour earlier for Europeans next week and the week after
15:05:21 <tinkster> I will probably have to send regrets for next two weeks then.
15:05:23 <Steven> zakim, mute me
15:05:23 <Zakim> Steven should now be muted
15:05:35 <Steven> Topic: Action Items
15:05:38 <manu>
15:05:54 <Steven> Manu: Action 5 for Ivan?
15:05:57 <RobW> RobW has joined #rdfa
15:06:12 <Steven> ... mark as done?
15:06:15 <manu> ACTION-5?
15:06:15 <trackbot> ACTION-5 -- Mark Birbeck to generate spec text for pulling in external vocabulary documents -- due 2010-03-18 -- OPEN
15:06:15 <trackbot>
15:06:19 <Steven> Ivan: the discussion is still ongoing
15:06:22 <manu> trackbot, close ACTION-5 
15:06:22 <trackbot> ACTION-5 Generate spec text for pulling in external vocabulary documents closed
15:06:46 <manu> trackbot, comment ACTION-5 Ivan produced a merged specification explaining how to pull in external vocabulary documents.
15:06:46 <trackbot> ACTION-5 Generate spec text for pulling in external vocabulary documents notes added
15:06:56 <Steven> Manu: URL for that Ivan?
15:07:04 <Steven> Ivan: Just a moment, watch the IRC
15:07:24 <Steven> Manu: I will fix the descriptions of the list
15:07:28 <ivan> -> vocabulary document (version 1)
15:07:38 <Steven> Regrets: MarkB, Ben_Adida
15:07:52 <Steven> Topic: ISSUE-1 RDFa Vocabularies (on Mark)
15:07:53 <ivan> -> vocabulary document (version 2)
15:07:56 <manu> The things that we may have consensus on:
15:07:58 <manu> * RDFa profiles are specified in an external document (profile document)
15:08:00 <manu> * We should use the @profile attribute to specify the profile document
15:08:01 <manu> * The @profile attribute can be placed on any element and is scoped to the element on which it is defined and its children
15:08:05 <manu> * The profile document is marked up in RDFa, using a vocabulary designed to modify the behavior of the RDFa Processor
15:08:08 <manu> * The default profile document can be specified in the RDFa Core spec. This document will outline what prefixes and tokens are pre-defined
15:08:11 <manu> * The profile document can specify tokens and prefixes
15:08:13 <manu> * One does not use xmlns: to declare prefixes and tokens
15:08:17 <Zakim> +RobW
15:09:22 <ivan> q+
15:09:33 <Steven> rrsagent, make minutes
15:09:33 <RRSAgent> I have made the request to generate Steven
15:09:50 <tinkster> ... but that <head profile> applies to *whole* document.
15:09:54 <Steven> Ivan: I'm not sure all of these do have consensus
15:10:05 <Steven> ... such as the xmlns one
15:10:23 <Steven> Chair: Manu
15:10:38 <Zakim> -ShaneM
15:10:41 <Zakim> +ShaneM
15:11:17 <Steven> Manu: I thought there was opposition to the JSON method, so then there was one proposal left
15:11:27 <Steven> Ivan: There are two issues
15:11:46 <Steven> ... whether we use an RDF vocabulary for prefixes and tokens, and then how we serialise
15:12:08 <Steven> ... I thought Mark was not in favour of the first bit
15:12:12 <Steven> ... though I and Ben are
15:12:39 <Steven> Manu: So the last bullet point and what Ivan has just said are dependent on each other
15:12:51 <Steven> ... Mark said we should be able to use xmlns for prefixes and tokens
15:12:55 <Steven> Ivan: You are right
15:13:00 <Steven> ... I am against that as well
15:13:40 <Steven> Manu: There was a problem of leakage of prefixes into the authors document
15:14:36 <Steven> ... we may have consensus on the RDFa as profile bit
15:14:54 <Steven> ... we may want dc and foaf in the predefined prefixes
15:15:13 <Steven> ... we would do that by saying if there is no profile specified then use this one by default
15:15:17 <Steven> ... agree?
15:15:26 <Steven> q+
15:15:33 <ivan> ack ivan
15:15:39 <Steven> ack me
15:15:50 <manu> Steven: Do we really need to have a default profile? 
15:15:56 <ivan> q+
15:16:26 <Steven> Manu: we wanted to have a default case that was available without using profile
15:16:36 <tinkster> Would the default profile apply to XHTML+RDFa 1.1? or RDFa Core 1.1?
15:17:11 <Steven> Steven: What is the advantage over saying that the defaults are always there?
15:17:37 <Steven> Manu: There are two possibilities: overlaying your profile over the default
15:18:09 <Steven> ... or replacing the default with your profile
15:18:23 <tinkster> Other host languages might prefer different default profiles.
15:18:57 <ivan> q?
15:19:00 <Steven> Manu: Answering Toby's question [scribe missed]
15:19:14 <Steven> Manu: Does ODF have a viewpoint on this?
15:19:19 <Steven> Rob: Not really
15:19:34 <Steven> Manu: I would expect ODF to want a different set of defaults
15:20:08 <Steven> Rob: The vocabs we are seeing in ODF1.2 are about embedded vcards, events etc; no FOAF
15:20:28 <Steven> q+
15:20:40 <Steven> Ivan: My proposal is we should postpone this discussion
15:20:48 <Steven> ... we don't know what a profile doc will contain
15:21:01 <Steven> ... so the default issue is premature
15:21:32 <Steven> Manu: Fine
15:21:40 <Steven> q-
15:22:07 <ivan> q-
15:22:28 <Steven> Steven: For ODF there is no real problem with always having an explicit @profile, since the authoring arguments don't apply
15:23:03 <Steven> Manu: If we want the concept of a default profile we need to be able to support prefixes in a profile document
15:23:26 <Steven> rrsagent, make minutes
15:23:26 <RRSAgent> I have made the request to generate Steven
15:23:32 <Steven> Ivan: I think the list if fine
15:23:58 <Steven> ... I'm not sure if we have consensus about dropping JSON
15:24:27 <Steven> Manu: There are security implications associated with it, and CORS will solve it, and so will the RDFa API
15:24:47 <Steven> ... and we don't want to mark up in two different ways
15:24:49 <Steven> q+
15:25:03 <Steven> Ivan: What does Toby think?
15:25:20 <Steven> Toby: The format should be RDF of some kind
15:25:58 <Steven> ... in any serialisation, but only RDFa is the only required one
15:26:20 <Steven> q?
15:27:18 <ivan> q+
15:27:18 <Steven> Steven: I think it is the wrong way round - there is no consensus on *adding* JSON
15:27:25 <Steven> Shane: I agree strongly
15:27:41 <manu> The things that we still have to discuss:
15:27:43 <Steven> Manu: I would still like to hear Mark; he will have to fight hard though
15:27:43 <manu> * What happens when you can't dereference the profile document? (Toby's proposal)
15:27:45 <manu> * Are we limiting next/prev/index/license/etc to @rel/@rev or allowing them everywhere?
15:27:46 <ivan> ack Steven 
15:27:46 <manu> * What is the mental model are tokens/prefixes two different concepts in RDFa or are they the same thing?
15:27:47 <ivan> q-
15:27:48 <manu> * Are there backwards compatibility issues with the proposed path forward?
15:28:04 <Steven> Ivan: I agree with Toby
15:28:17 <Steven> ... RDFa is the only required serialization
15:28:17 <ShaneM> Me too
15:28:45 <Steven> zakim, mute me
15:28:45 <Zakim> Steven should now be muted
15:29:37 <Steven> Manu: Mark seems to be concerned with the relation between token and prefix
15:29:55 <Steven> ... and there are backward compatibility issues
15:30:04 <Steven> ... Any other issues?
15:30:12 <Steven> Ivan: No
15:30:46 <Steven> ... how will we decide?
15:31:27 <Steven> Agenda:
15:31:33 <Steven> rrsagent, make minutes
15:31:33 <RRSAgent> I have made the request to generate Steven
15:32:17 <Steven> Ivan: We have already had two versions of this document
15:32:50 <Steven> ... I would like to see a feeling for which direction
15:33:45 <Steven> ... we have to move on
15:33:49 <Steven> q+
15:33:54 <Steven> ack me
15:34:19 <manu> Steven: There is no immediate hurry to move forward - we may want to let this stuff sink in for a while.
15:34:28 <Steven> zakim, mute me
15:34:28 <Zakim> Steven should now be muted
15:35:07 <Steven> Manu: A lot of the decisions are interrelated, and that's why I would like a bit more time to hold back on making a firm decision
15:35:57 <Steven> Manu: I think we should point to the latest document, and then work with that
15:36:48 <Steven> Ivan: The decision on the restriction of tokens to @rel @rev is important
15:36:57 <tinkster> Another possibility is allowing profiles to define keywords that only apply to particular attributes.
15:37:07 <ivan> q+
15:37:08 <Steven> Manu: Anyone object to allowing all tokens everywhere?
15:37:25 <tinkster> e.g. typeof="Person"
15:38:06 <manu> q+ manu
15:38:10 <manu> ack ivan
15:38:13 <Steven> Ivan: Then the management of keywords and prefixes becomes very different
15:38:21 <Steven> Shane: For an implementation?
15:38:25 <Steven> Ivan: No
15:39:02 <Benjamin>
15:39:10 <Steven> Topic: RDFa API Direction
15:39:30 <Steven> Benjamin: See the above mail
15:39:35 <Steven> ... why is an API needed?
15:39:49 <Steven> ... I looked at the code  of some of the libraries
15:40:03 <Steven> ... and how could an API help to reduce them
15:40:15 <Steven> ... conclusion - most of the code is for HTML attributes
15:40:27 <Steven> ... and so an API could help
15:40:39 <Steven> ... developers have to use some form of recursion
15:40:44 <Steven> ... an API may help that
15:40:55 <tinkster> yes
15:40:56 <Steven> ... I looked at Operator for Firefox
15:40:58 <manu> yes
15:40:59 <Knud> yup
15:41:21 <Steven> ... RDFa DOM API may help for that sort of app
15:41:50 <Steven> ... an API can hide the difference between URIs and CURIEs
15:42:02 <Steven> ... and external definitions in profiles
15:42:12 <manu> q+
15:43:07 <Steven> Manu: Are we focussing on RDFa parser developers, or web page developers?
15:43:12 <Steven> ... I think the latter
15:43:24 <ShaneM> q+ to ask about audience
15:43:25 <tinkster> Certainly, to help page authors. The parser would be built into the browser.
15:43:30 <manu> ack manu
15:43:34 <Knud> I think the latter
15:43:36 <manu> ack [IP
15:43:48 <manu> ack ShaneM
15:43:48 <Zakim> ShaneM, you wanted to ask about audience
15:44:34 <tinkster> DocA loads DocB in an iframe, and extracts triples from DocB.
15:44:51 <Knud> useful for mashups?
15:44:54 <Steven> Shane: Who is our audience for this?
15:45:18 <Steven> Manu: App writers, crawlers
15:45:59 <Benjamin> q+
15:46:43 <tinkster> Also GreaseMonkey/Opera User Scripts...
15:46:45 <Steven> ... extracting the triples
15:46:58 <Steven> Shane: So native in a browser, or a library?
15:47:07 <Steven> Manu: Yes
15:47:13 <manu> ack Benjamin
15:47:32 <Steven> Benjamin: If we have an API, we don't need RDFa parsers anymore?
15:47:32 <tinkster> The parser powers the API.
15:47:34 <Steven> Manu: Yes
15:47:45 <Steven> Shane: At least on the client side
15:48:06 <Steven> Ivan: So my distiller will still be used.
15:48:14 <tinkster> Even though we have XML DOM, we still need XML parsers!
15:48:19 <Steven> Manu: We want to make it easier for web developers to use
15:48:40 <Steven> rrsagent, make minutes
15:48:40 <RRSAgent> I have made the request to generate Steven
15:49:06 <Steven> Benjamin: So the real focus is to extract RDF triples
15:49:15 <Steven> ... and it should be possible to query
15:49:27 <manu> q+ to discuss add/removal of RDF triples
15:49:29 <Steven> ... add triples, and remove them
15:49:42 <Steven> ... those last two may be optional
15:49:51 <manu> ack [IP
15:49:51 <Zakim> [IPcaller], you wanted to discuss add/removal of RDF triples
15:50:05 <Steven> zakim, [IP is Manu
15:50:05 <Zakim> +Manu; got it
15:50:16 <ivan> +1 to the current order
15:50:23 <Steven> Manu: Not sure about 2, and against 3 and 4
15:50:35 <tinkster> #3 is hard; #4 is easy but not especially useful without #3.
15:50:36 <Steven> ... at least in the first version
15:50:43 <Steven> ... maybe we can build it up by stages
15:51:15 <ShaneM> I agree with Toby - you would need a CSS selector-like query interface... SPARQL in the browser
15:51:35 <Steven> Manu: It would be difficult to do 3 and 4
15:51:51 <Steven> Ivan: I think 1 and 2 should be the focus for now
15:52:20 <Steven> Benjamin: We need to define the cut between the RDFa DOM API and the triplestore API
15:52:46 <ivan> q+
15:52:57 <Steven> Manu: Big unanswered question
15:53:05 <Steven> Ivan: Toby collected some APIs as examples
15:53:09 <tinkster>
15:53:19 <manu> q+ to discuss how this hooks into ODF and SVG
15:53:23 <manu> ack ivan
15:53:31 <Steven> ... but what a triplestore API can do in a browser is unclear at the moment
15:54:05 <Steven> ... it is right to divide them
15:54:23 <manu> ack Manu
15:54:23 <Zakim> Manu, you wanted to discuss how this hooks into ODF and SVG
15:54:26 <Steven> ... for the time being, treat as separate
15:54:39 <ShaneM> +1 to permitting extracted triples to be put into a local triple store
15:55:04 <Steven> Manu: We may want to decide if there are triggers that require the one API to use the other
15:55:25 <Steven> ... safety and privacy issues need attention
15:55:34 <Steven> ... shouldn't focus on the triplestore API
15:55:59 <Steven> ... we may want to see how the DOM API matches the SVG DOM API
15:56:05 <Steven> ... and there's ODF as well
15:56:17 <Steven> Rob: No standardised DOM representation as of now
15:56:28 <Steven> Manu: We should watch that though
15:56:40 <Steven> .. and talk to Doug Schepers too
15:57:02 <Steven> Ivan: I have used the SVG DOM, I don't foresee a problem
15:57:16 <Steven> ... it is a read-only API
15:57:35 <Benjamin> q+ to talk about the first sketch at
15:57:46 <Steven> ... only if we start adding and removing triples do I see a problem
15:57:49 <manu> ack Benjamin
15:57:49 <Zakim> Benjamin, you wanted to talk about the first sketch at
15:58:07 <Steven> Benjamin: Just to mention the first version
15:58:38 <ShaneM> Do we envision this is a 'live' list that is updated as there are mutation events, or a static list that must be updated by the developer as needed?
15:58:38 <Steven> ... we should play with it
15:58:41 <Steven> ... try it out
15:58:51 <ivan> q+
15:58:57 <manu> ack ivan
15:59:23 <Steven> Ivan: Looking at the microdata API would be a good comparison
15:59:24 <manu> q+ to end the meeting.
15:59:40 <Steven> ... try to keep them similar
15:59:44 <tinkster> IIRC microdata API is quite resource-based, whereas current RDFa suggestion quite triple-based.
15:59:59 <Steven> ack me
16:00:04 <Steven> q+
16:00:25 <manu> ack Manu
16:00:25 <Zakim> Manu, you wanted to end the meeting.
16:00:27 <Steven> Ivan: Don't forget the time changes
16:00:28 <manu> ack Steven
16:01:05 <Steven> Steven: Ivan and I can't make the call in two week's time, because of the W3C AC meeting, and Ivan will miss the week after that as well. We should both be here next week.
16:01:44 <Steven> rrsagent, make minutes
16:01:44 <RRSAgent> I have made the request to generate Steven