14:49:48 <RRSAgent> RRSAgent has joined #annotation
14:49:48 <RRSAgent> logging to http://www.w3.org/2016/04/08-annotation-irc
14:50:13 <Zakim> Zakim has joined #annotation
14:50:47 <TimCole> Meeting: Web Annotation Working Group
14:51:00 <TimCole> Chair: TimCole
14:52:22 <TimCole> Agenda: https://lists.w3.org/Archives/Public/public-annotation/2016Apr/0012.html
14:56:33 <dwhly> +Present Dan_Whaley
14:59:37 <TimCole> Regrets: Ivan Herman
15:00:14 <tbdinesh> tbdinesh has joined #annotation
15:00:18 <TimCole> Regrets: Ben De Meester
15:01:16 <TimCole> Regrets: Rob Sanderson
15:01:45 <TimCole> Regrets: Kanai, Takeshi
15:02:18 <TimCole> Meeting number is: 645 413 954
15:02:30 <tbdinesh> Present+ TB_Dinesh
15:02:58 <TimCole> Regrets: Salisbury, Davi
15:03:06 <TimCole> s/Davi/Davis
15:03:45 <TimCole> Agenda: https://lists.w3.org/Archives/Public/public-annotation/2016Apr/0012.html
15:04:13 <ShaneM> present+ shepazu
15:04:17 <ShaneM> present+ ShaneM
15:04:28 <TimCole> Present+ TimCole
15:04:44 <fjh> fjh has joined #annotation
15:04:45 <nickstenn> Present+ Nick_Stenning
15:05:04 <TimCole> ScribeNick: Nickstenn
15:05:17 <TimCole> Topic: Announcements?
15:06:02 <nickstenn> dwhly: Two things. 1) We are firming up the schedule for I Annotate and are about to announce the accepted presentations today. About 32 different applications.
15:06:15 <nickstenn> ... going to have a set of full presentations and some flash talks
15:06:27 <nickstenn> ... also planning a 90 minute session on abuse and "consent to be annotated"
15:06:35 <nickstenn> ... asking for suggestions of panelists or facilitators
15:06:53 <nickstenn> ... either familiar suspects or others likely to be in Europe
15:06:58 <shepazu> q+
15:07:05 <TimCole> ack shep
15:07:32 <nickstenn> shepazu: I don't know anyone in Europe, but probably can think of a few people. Will ask and get back to you.
15:07:35 <fjh> Present+ Frederick_Hirsch
15:08:10 <nickstenn> ... two ideas ... whoever wrote "The Internet is Garbage", and whoever wrote "Reading the Comments"
15:08:34 <TimCole> Topic: Minutes Review
15:08:41 <nickstenn> ... [Sarah Jeong and Joseph M. Reagle Jr. respectively]
15:08:44 <TimCole> PROPOSED RESOULTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html
15:09:07 <nickstenn> RESOULTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html
15:09:11 <nickstenn> RESOLUTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html
15:09:22 <nickstenn> s/RESOULTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html//
15:09:36 <nickstenn> TimCole: two main topics for today
15:09:37 <TimCole> Topic: HTML Serialization
15:09:40 <PaoloCiccarese> PaoloCiccarese has joined #annotation
15:09:45 <bigbluehat> Present+ Benjamin_Young
15:09:48 <nickstenn> ... HTML serialization and then later
15:09:53 <nickstenn> ... a discussion about testing
15:10:09 <TimCole> https://github.com/w3c/web-annotation/issues/147
15:10:37 <nickstenn> ... what is the thinking of how to serialize annotations in HTML
15:10:45 <nickstenn> ... would a non-normative note from the WG be appropriate?
15:10:46 <TimCole> q?
15:10:56 <shepazu> q+
15:11:10 <PaoloCiccarese> Present+ Paolo_Ciccarese
15:11:20 <bigbluehat> do we have a measure of how RDFa may/would be considered insufficient?
15:11:36 <nickstenn> ... I looked at a couple of simple use cases where one wants to add into HTML some links, footnotes, etc.
15:12:06 <nickstenn> ... another suggestion (from the JSON-LD spec) is to include the JSON-LD in a script tag
15:12:11 <nickstenn> ... also microdata or RDFa
15:12:31 <nickstenn> ... but RDFa requires you use the namespaces (and full property names) from the vocabulary
15:12:32 <bigbluehat> JSON-LD in script tags is also what Google / Schema.org recommend for adding "Inbox Actions" to email fwiw
15:12:49 <nickstenn> ... whereas in JSON-LD some of this complexity is hidden by the JSON-LD context
15:13:14 <nickstenn> ... if someone knows a way around this for RDFa that would be interesting to know
15:13:14 <shepazu> bigbluehat, got a reference URL?
15:13:55 <bigbluehat> https://developers.google.com/gmail/markup/actions/actions-overview
15:14:16 <bigbluehat> this was in reference to using JSON-LD in script tags in HTML
15:14:24 <nickstenn> ... schema.org uses the same URI for namespace and JSON-LD context
15:14:34 <nickstenn> ... no keys are renamed
15:14:40 <bigbluehat> here's a more exemplary page https://developers.google.com/gmail/markup/getting-started#your_first_markup
15:14:50 <ShaneM> q+ to ask who we are in this case?
15:15:04 <TimCole> ack shep
15:15:35 <nickstenn> shepazu: Before the WG I experimented with using RDFa to map the data model into HTML
15:15:44 <nickstenn> ... my experience was not only was it difficult to do
15:15:56 <nickstenn> ... had to chat with several experts on how to do it (who disagreed with one another)
15:16:15 <nickstenn> ... my experience is that it it's very difficult for the average person to use RDFa
15:16:21 <nickstenn> ... includes adding a lot of extra markup
15:16:28 <PaoloCiccarese> One example: https://www.w3.org/community/openannotation/wiki/RDFa
15:16:32 <bigbluehat> an older experiment of mine on RDFa+HTML for Annotation http://bl.ocks.org/BigBlueHat/3068c1e0cb459c048e76
15:16:41 <nickstenn> ... using RDFa per se seems like it might be prohibitively difficult
15:16:46 <TimCole> q?
15:16:59 <csarven> nickstenn Hypothetical :)
15:17:07 <csarven> and q
15:17:45 <bigbluehat> q+ to ask what the goal of HTML serialization is specifically
15:18:04 <nickstenn> shepazu: one way to look at this is that  the markup for annotations could be similar to the markup for comments and footnotes
15:18:22 <nickstenn> ... if we wanted to get the most utility of something, we might want to consider a more general case than just annotations
15:18:36 <nickstenn> ... and that might get more interest from browser vendors
15:18:36 <shepazu> http://schepers.cc/annotations/note-element/note-element.html
15:18:59 <nickstenn> ... ^ a quick demo using web components to create a custom note element in HTML
15:19:15 <ShaneM> I think W3C calls that "custom elements" now ?
15:19:16 <nickstenn> ... purely a tech demo
15:19:47 <ShaneM> zakim, agenda?
15:19:47 <Zakim> I see nothing on the agenda
15:20:11 <nickstenn> ... if we really want to solve a problem for an HTML serialization, my opinion is that we should be looking to solve a more general problem than just annotation in HTML, with as few new attributes as possible
15:20:20 <csarven> q+
15:20:30 <nickstenn> ... if, say, we added a single <note> element to HTML
15:20:32 <TimCole> Agenda: https://lists.w3.org/Archives/Public/public-annotation/2016Apr/0012.html
15:20:40 <TimCole> ack ShaneM
15:20:40 <Zakim> ShaneM, you wanted to ask who we are in this case?
15:21:20 <nickstenn> ShaneM: On the subject of RDFa as a mechanism for annotating... I'm an RDFa champion...
15:21:38 <csarven> I think I missed the relevance or a need of a new element? What's the UC exactly?
15:21:58 <nickstenn> ... DPUB folks have been working with accessibility folks for a while and have some prior work on note and note-ref [?] elements
15:22:16 <nickstenn> ... we have not yet considered how to inform the annotation environment of note elements
15:22:42 <TimCole> ack bigb
15:22:42 <Zakim> bigbluehat, you wanted to ask what the goal of HTML serialization is specifically
15:22:58 <shepazu> (Shane, you and I have talked about this in the past, BTW :) )
15:23:08 <nickstenn> bigbluehat: I'd like us to scope what specifically the goals for an HTML serialisation are
15:23:25 <nickstenn> ... what are we trying to provide? merely upgrades for comments at the bottom of a post
15:23:33 <nickstenn> ... or are we aiming for in-context display of the content
15:23:36 <shepazu> q+
15:23:51 <nickstenn> ... what sort of things do we expect to gain from it being serialized in HTML
15:24:01 <nickstenn> ... as opposed to what is technically possible now
15:24:10 <nickstenn> TimCole: any thoughts on answers to those questions?
15:24:41 <nickstenn> bigbluehat: aim to help the existing "low-end" annotations (e.g. footnotes, comments) ... give them a path to "upgrade" to something more meaningful
15:24:54 <nickstenn> ... giving them more data and meaning within the HTML
15:25:51 <nickstenn> ... as far as in-context display goes, the JSON-LD seems the most direct route
15:26:08 <nickstenn> ... otherwise we are going to have to reproduce all kinds of (e.g. selector) data in the HTML serialisation
15:26:26 <TimCole> ack csa
15:26:28 <csarven> eg Footnote annotation: http://csarven.ca/dokieli#596975 displayed as an aside. Similar mechanism for references, and other social interactions. See also: https://github.com/w3c/web-annotation/issues/147#issuecomment-207419065 for a general purpose annotation UC.
15:26:29 <ShaneM> +1 to understanding what problem we are trying to solve
15:26:29 <nickstenn> ... but the important thing is to identify *what* we're aiming to achieve beyond representing model data in HTML
15:27:10 <nickstenn> csarven: I agree with bigbluehat on identifying the usecases more clearly -- not yet entirely clear
15:27:15 <tbdinesh> (agree with benjamin.. xpaths change with RDFa serialization)
15:27:49 <nickstenn> ... my question is: what is the need for coming up with new elements/attributes from the HTML side of things?
15:28:03 <bigbluehat> ShaneM: could you drop a link to the DPUB conversation around a note element (rashly assuming it has a URL ;) )
15:28:19 <nickstenn> ... if the goal is to have annotations semantically represented, then that points towards RDFa
15:29:06 <nickstenn> ... would it be worth distinguishing between the need for new HTML elements and the full serialisation of the model as JSON-LD or RDFa in HTML?
15:29:27 <ShaneM> RDFa has the advantage of being a W3C recommendation that is already part of HTML5.
15:29:28 <TimCole> q?
15:29:46 <TimCole> ack shep
15:29:55 <csarven> present+
15:30:12 <csarven> present+ csarven
15:30:22 <nickstenn> shepazu: along the lines of what bigbluehat was saying ... good next steps would be for us to spend some time identifying the outcomes we want [from the HTML serialisation work]
15:30:38 <nickstenn> ... but also thinking about this work as part of a larger set of things: footnotes, comment, etc.
15:31:07 <nickstenn> ... and then perhaps rather than publishing a note in this group, it might be best if we gave the feedback from that process back to the Digital Publishing Interest Group
15:31:22 <nickstenn> ... and that might help shift some of this work over to them where it could find a longer-term home
15:31:33 <tbdinesh> q+ html serialization is an associated page?
15:31:58 <bigbluehat> +1 to TimCole's summary
15:32:21 <nickstenn> TimCole: it seems there's enough confusion on different motivations supporting this topic that we're probably not going to converge on solutions, but we might converge on identified usecases
15:32:36 <nickstenn> shepazu: how do we want to structure the work in this WG?
15:32:52 <nickstenn> TimCole: spend a couple of week collecting new use cases?
15:33:30 <csarven> Sounds good.
15:33:31 <nickstenn> ... solicit more input on goals/use cases through GitHub and the mailing list
15:33:36 <nickstenn> ... any objections?
15:33:44 <nickstenn> ... [crickets]
15:34:12 <TimCole> Topic: Testing
15:34:25 <TimCole> Scribenick: dwhly
15:34:47 <TimCole> https://github.com/w3c/web-annotation/issues/203
15:34:53 <dwhly> TimCole:  Progress on last couple of calls around testing.
15:35:20 <dwhly> ... There are some questions raised in the issue above ^
15:35:40 <dwhly> ... What is a media type in a binary data file.
15:36:03 <dwhly> ... How do features in the data model relate to media types.
15:36:13 <dwhly> ... Can anyone get us going on this?
15:36:47 <TimCole> https://github.com/w3c/web-annotation/issues/203
15:36:51 <dwhly> ... I think it's possible to get to a raw table of the data.
15:36:59 <TimCole> https://github.com/w3c/web-annotation/blob/media-selectors/model/medias.html
15:37:45 <dwhly> ... In trying to figure out what are testing requirements are, is it something that the client implements, annotation repository, or another ecosystem service?
15:37:59 <dwhly> ... How do the tests break down by the class of agent?
15:38:14 <shepazu> q+
15:38:19 <TimCole> ack shep
15:38:39 <dwhly> Shepazu: I don't think we should break down by the class of agent, comes later.
15:38:50 <dwhly> ... Focus on the testing first.
15:39:11 <dwhly> TimCole: First, go back through the documents identify testable features.
15:39:31 <ShaneM> q+ to talk about picking out testable statements
15:39:35 <dwhly> Shepazu: Yeah, first we do testable assertions, then we write tests.
15:39:57 <dwhly> ... Looking through the spec, I don't think it's spelled out different conformance clauses for different agents.
15:40:07 <dwhly> ... Same testing methodology should apply to all agents.
15:40:26 <dwhly> ... Unless it affects which tests we write, we shouldn't care what is being annotated.
15:41:21 <ShaneM> I note this page does not work now: https://www.w3.org/annotation/ because the embedded image uses a protocol and it is http:
15:41:27 <TimCole> ack ShaneM
15:41:27 <Zakim> ShaneM, you wanted to talk about picking out testable statements
15:41:39 <dwhly> ShaneM: I agree w/ doug.
15:42:00 <tantek> tantek has joined #annotation
15:42:23 <dwhly> ... Identifying the testable statements is good.  In parallel, we should do a little infrastructure work, because most of the testing you care about, can be easily automated if you have the infrastructure in place.
15:42:48 <dwhly> ... Then we take testable statements, crafting tests.
15:43:18 <dwhly> ... in terms of identifying conformance clauses, it's not a critical steps, but there are definitely different types of testiable agents.
15:43:46 <dwhly> ... What matters is that there are multiple implementations for each feature.  Thats how you know you've finished.
15:44:04 <dwhly> TimCole: A lot of us on this group don't have proper experience.
15:44:16 <dwhly> ... Is there any training that would be helpful?
15:44:22 <dwhly> ShaneM: There is
15:44:24 <ShaneM> https://www.w3.org/TR/test-methodology/
15:44:28 <dwhly> ... A nice note from the W3C ^
15:44:39 <dwhly> ... Consumable by everyman.
15:44:51 <dwhly> ... Gives techniques for testable assertions.
15:45:35 <dwhly> ... In our spec there are lots of places where it says an implementation must do this, etc. Those are all test. assertions.
15:46:01 <dwhly> ... The musts, mays, shoulds here are teh testable assertions.
15:46:22 <dwhly> ... Determine if its reasonable.  Did we mean that?  #2 Is it testable?
15:47:19 <dwhly> ... Part of the review can be giving comments back, at the end we'll have a list of testable assertions.
15:47:32 <dwhly> ... If we don't have enough, people will push back.
15:48:01 <dwhly> Shepazu: Corallary, not only do we have tests, but we also need to have implementations.
15:48:19 <dwhly> ShaneM: And if you don't then those features need to be carved out.
15:48:39 <dwhly> ... or we create "fake" implementations.
15:48:51 <dwhly> TimCole: Sounds like a multi-person endeavor.
15:49:01 <dwhly> ... Task force time?
15:49:12 <dwhly> ... Doug, how do we get this going?
15:49:12 <ShaneM> by fake I mean implementations that exercise features even if the implemenations are not commercial (open source sample or reference implementations).
15:49:34 <dwhly> shepazu: I think we should assign someone.
15:49:41 <dwhly> ... they can start and assign actions.
15:49:55 <dwhly> ... and drive the process.
15:50:25 <dwhly> ... then we can track results, etc.
15:50:29 <TimCole> q?
15:50:46 <dwhly> TimCole: Yep.  Do we have anyone that's willing to kick it off?
15:51:03 <dwhly> ... Someone could perhaps offer some testable assertions?
15:51:13 <dwhly> Shepazu: Shane you and I could discuss off list.
15:51:22 <nickstenn>  I'm also happy to contribute to that process
15:51:34 <dwhly> ShaneM: That sounds good.
15:51:42 <dwhly> TimCole: And nick.
15:52:00 <dwhly> ... In an upcoming call we can highlight and get some actions rolling.
15:52:18 <dwhly> ... Do you guys need a week, two?
15:52:34 <dwhly> ShaneM: Lets prime the pump.
15:52:56 <dwhly> TimCole: Would be nice to enter the F2F w/ progress.
15:53:21 <dwhly> Shepazu: It's nice to find test. assertions.  But if you know the methodology, it gets easier.
15:53:27 <TimCole> q?
15:53:30 <dwhly> TimCole: Any more questions around testing?
15:54:04 <dwhly> Any other things folks want to raise?
15:54:28 <dwhly> ... Pls post examples of HTML serialization
15:54:37 <dwhly> ... How far would we like to go in a note?
15:54:44 <dwhly> ... Pls think about it.
15:54:55 <dwhly> ... We will revisit in 2 weeks
15:55:03 <dwhly> ... Annnnd..... we're done!
15:56:22 <TimCole> TimCole has joined #annotation
15:57:04 <TimCole> rrsagent, make log public
15:57:14 <TimCole> rrsagent, draft minutes
15:57:14 <RRSAgent> I have made the request to generate http://www.w3.org/2016/04/08-annotation-minutes.html TimCole
15:57:28 <TimCole> rrsagent, make log public
16:01:17 <fjh> fjh has left #annotation