Web Annotation Working Group

<TimCole> Agenda: https://lists.w3.org/Archives/Public/public-annotation/2016Apr/0012.html

<TimCole> Scribenick: nickstenn

Announcements?

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.
... going to have a set of full presentations and some flash talks
... also planning a 90 minute session on abuse and "consent to be annotated"
... asking for suggestions of panelists or facilitators
... either familiar suspects or others likely to be in Europe

shepazu: I don't know anyone in Europe, but probably can think of a few people. Will ask and get back to you.
... two ideas ... whoever wrote "The Internet is Garbage", and whoever wrote "Reading the Comments"

shepazu: [Sarah Jeong and Joseph M. Reagle Jr. respectively]

Minutes Review

<TimCole> PROPOSED RESOLUTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html

RESOLUTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/01-annotation-minutes.html

TimCole: two main topics for today

TimCole: HTML serialization and then later
... a discussion about testing

HTML Serialization

<TimCole> https://github.com/w3c/web-annotation/issues/147

TimCole: what is the thinking of how to serialize annotations in HTML
... would a non-normative note from the WG be appropriate?

<bigbluehat> do we have a measure of how RDFa may/would be considered insufficient?

TimCole: I looked at a couple of simple use cases where one wants to add into HTML some links, footnotes, etc.
... another suggestion (from the JSON-LD spec) is to include the JSON-LD in a script tag
... also microdata or RDFa
... but RDFa requires you use the namespaces (and full property names) from the vocabulary

<bigbluehat> JSON-LD in script tags is also what Google / Schema.org recommend for adding "Inbox Actions" to email fwiw

TimCole: whereas in JSON-LD some of this complexity is hidden by the JSON-LD context
... if someone knows a way around this for RDFa that would be interesting to know

<shepazu> bigbluehat, got a reference URL?

<bigbluehat> https://developers.google.com/gmail/markup/actions/actions-overview

<bigbluehat> this was in reference to using JSON-LD in script tags in HTML

TimCole: schema.org uses the same URI for namespace and JSON-LD context
... no keys are renamed

<bigbluehat> here's a more exemplary page https://developers.google.com/gmail/markup/getting-started#your_first_markup

shepazu: Before the WG I experimented with using RDFa to map the data model into HTML
... my experience was not only was it difficult to do
... had to chat with several experts on how to do it (who disagreed with one another)
... my experience is that it it's very difficult for the average person to use RDFa
... includes adding a lot of extra markup

<PaoloCiccarese> One example: https://www.w3.org/community/openannotation/wiki/RDFa

<bigbluehat> an older experiment of mine on RDFa+HTML for Annotation http://bl.ocks.org/BigBlueHat/3068c1e0cb459c048e76

shepazu: using RDFa per se seems like it might be prohibitively difficult

<csarven> nickstenn Hypothetical :)

<csarven> and q

shepazu: one way to look at this is that the markup for annotations could be similar to the markup for comments and footnotes
... if we wanted to get the most utility of something, we might want to consider a more general case than just annotations
... and that might get more interest from browser vendors

<shepazu> http://schepers.cc/annotations/note-element/note-element.html

shepazu: a quick demo using web components to create a custom note element in HTML

<ShaneM> I think W3C calls that "custom elements" now ?

shepazu: purely a tech demo
... 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
... if, say, we added a single <note> element to HTML

<csarven> I think I missed the relevance or a need of a new element? What's the UC exactly?

<Zakim> ShaneM, you wanted to ask who we are in this case?

ShaneM: On the subject of RDFa as a mechanism for annotating... I'm an RDFa champion...

ShaneM: DPUB folks have been working with accessibility folks for a while and have some prior work on note and note-ref [?] elements
... we have not yet considered how to inform the annotation environment of note elements

<shepazu> (Shane, you and I have talked about this in the past, BTW :) )

<Zakim> bigbluehat, you wanted to ask what the goal of HTML serialization is specifically

bigbluehat: I'd like us to scope what specifically the goals for an HTML serialisation are
... what are we trying to provide? merely upgrades for comments at the bottom of a post
... or are we aiming for in-context display of the content
... what sort of things do we expect to gain from it being serialized in HTML
... as opposed to what is technically possible now

TimCole: any thoughts on answers to these questions?

bigbluehat: aim to help the existing "low-end" annotations (e.g. footnotes, comments) ... give them a path to "upgrade" to something more meaningful
... giving them more data and meaning within the HTML
... as far as in-context display goes, the JSON-LD seems the most direct route
... otherwise we are going to have to reproduce all kinds of (e.g. selector) data in the HTML serialisation

<ShaneM> +1 to understanding what problem we are trying to solve

<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.

bigbluehat: but the important thing is to identify *what* we're aiming to achieve beyond representing model data in HTML

csarven: I agree with bigbluehat on identifying the usecases more clearly -- not yet entirely clear

<tbdinesh> (agree with benjamin.. xpaths change with RDFa serialization)

csarven: my question is: what is the need for coming up with new elements/attributes from the HTML side of things?

<bigbluehat> ShaneM: could you drop a link to the DPUB conversation around a note element (rashly assuming it has a URL ;) )

csarven: if the goal is to have annotations semantically represented, then that points towards RDFa
... 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?

<ShaneM> RDFa has the advantage of being a W3C recommendation that is already part of HTML5.

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]
... but also thinking about this work as part of a larger set of things: footnotes, comment, etc.
... 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
... and that might help shift some of this work over to them where it could find a longer-term home

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

<bigbluehat> +1 to TimCole's summary

shepazu: how do we want to structure the work in this WG?

TimCole: spend a couple of week collecting new use cases?

<csarven> Sounds good.

TimCole: solicit more input on goals/use cases through GitHub and the mailing list
... any objections?
... [crickets]

Testing

<TimCole> Scribenick: dwhly

<TimCole> https://github.com/w3c/web-annotation/issues/203

TimCole:In this issue Ivan mentions a table of selectors by media type that he's made, as well as raising some related questions. I think it's possible to get to the raw table but the github.io link does not resolve.

<TimCole> https://github.com/w3c/web-annotation/blob/media-selectors/model/medias.html

TimCole: Progress on Testing during last couple of calls around testing.
... For example, there are some questions raised in the issue above ^
... What is mime media type for a binary data file?
... How do features in the data model relate to media types?
... Can anyone get us going on this?

TimCole: In trying to figure out what are testing requirements are, is it something that the client implements, annotation repository, or another ecosystem service?
... How do the tests break down by the class of agent?

Shepazu: I don't think we should break down by the class of agent, comes later.
... Focus on the testing first.

TimCole: So first, go back through the documents identify testable features.

Shepazu: Yeah, first we do testable assertions, then we write tests.
... Looking through the spec, I don't think it's spelled out different conformance clauses for different agents.
... Same testing methodology should apply to all agents.
... Unless it affects which tests we write, we shouldn't care what is being annotated.

<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:

<Zakim> ShaneM, you wanted to talk about picking out testable statements

ShaneM: I agree w/ doug.
... 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.
... Then we take testable statements, crafting tests.
... in terms of identifying conformance clauses, it's not a critical steps, but there are definitely different types of testiable agents.
... What matters is that there are multiple implementations for each feature. Thats how you know you've finished.

TimCole: A lot of us on this group don't have proper experience.
... Is there any training that would be helpful?

ShaneM: There is

<ShaneM> https://www.w3.org/TR/test-methodology/

ShaneM: A nice note from the W3C ^
... Consumable by everyman.
... Gives techniques for testable assertions.
... In our spec there are lots of places where it says an implementation must do this, etc. Those are all test. assertions.
... The musts, mays, shoulds here are teh testable assertions.
... Determine if its reasonable. Did we mean that? #2 Is it testable?
... Part of the review can be giving comments back, at the end we'll have a list of testable assertions.
... If we don't have enough, people will push back.

Shepazu: Corallary, not only do we have tests, but we also need to have implementations.

ShaneM: And if you don't then those features need to be carved out.
... or we create "fake" implementations.

TimCole: Sounds like a multi-person endeavor.
... Task force time?
... Doug, how do we get this going?

<ShaneM> by fake I mean implementations that exercise features even if the implemenations are not commercial (open source sample or reference implementations).

shepazu: I think we should assign someone.
... they can start and assign actions.
... and drive the process.
... then we can track results, etc.

TimCole: Yep. Do we have anyone that's willing to kick it off?
... Someone could perhaps offer some testable assertions?

Shepazu: Shane you and I could discuss off list.

<nickstenn> I'm also happy to contribute to that process

ShaneM: That sounds good.

TimCole: So Shane, Doug and nick will identify a few testable features
... and will put these in GitHub in a way that others can help identify more testable features.
... In an upcoming call we can highlight and get some actions rolling.
... Do you guys need a week, two, more?

ShaneM: Lets prime the pump.

TimCole: Would be nice to enter the F2F w/ progress.

Shepazu: It's nice to find test. assertions. But if you know the methodology, it gets easier.

TimCole: Any more questions around testing?

Any other things folks want to raise?

scribe: Pls post examples of HTML serialization
... How far would we like to go in a note?
... Pls think about it.
... We will revisit in 2 weeks
... Annnnd..... we're done!