14:48:15 <RRSAgent> RRSAgent has joined #annotation
14:48:15 <RRSAgent> logging to http://www.w3.org/2016/04/22-annotation-irc
14:48:20 <azaroth> trackbot, start meeting
14:48:22 <trackbot> RRSAgent, make logs public
14:48:22 <Zakim> Zakim has joined #annotation
14:48:24 <trackbot> Zakim, this will be 2666
14:48:24 <Zakim> ok, trackbot
14:48:25 <trackbot> Meeting: Web Annotation Working Group Teleconference
14:48:25 <trackbot> Date: 22 April 2016
14:48:37 <azaroth> Chair: Rob_Sanderson, Tim_Cole
14:48:43 <azaroth> Present+ Rob_Sanderson
14:50:01 <TimCole> TimCole has joined #annotation
14:51:07 <azaroth> Regrets+ Ben_de_Meester
14:53:44 <TimCole> Meeting: Web Annotation Working Group Teleconference
14:55:40 <TimCole> present+
14:55:49 <TimCole> present+ Tim_Cole
15:00:01 <tbdinesh> tbdinesh has joined #annotation
15:00:37 <ShaneM> present+ ShaneM
15:01:16 <tilgovi> tilgovi has joined #annotation
15:02:07 <ivan> Present+ Ivan
15:02:35 <bigbluehat> Present+ Benjamin_Young
15:03:02 <tilgovi> Present+ Randall_Leeds
15:03:34 <Loqi> *sniff*
15:03:47 <azaroth> scribenick: azaroth
15:04:01 <azaroth> TimCole: Let's get started
15:04:08 <azaroth> TOPIC: Agenda Review, Announcements
15:04:57 <azaroth> TimCole: (walks through agenda) Anything else we need to talk about?
15:05:10 <tbdinesh> present+ tb_dinesh
15:05:21 <takeshi> takeshi has joined #annotation
15:05:22 <davis_salisbury> davis_salisbury has joined #annotation
15:05:25 <dwhly> Present +dan_whaley
15:05:32 <azaroth> ... Okay. Want to announce that at the next couple of DPUB IG meetings will have topics of interest for this group
15:05:41 <davis_salisbury> present+ davis_salisbury
15:05:43 <TimCole> http://spec-ops.github.io/html-note/index.html
15:05:51 <azaroth> ... Draft note from Shane, any background?
15:06:01 <takeshi> Present+ Takeshi_Kanai
15:06:13 <azaroth> ShaneM: Happy to. Short story is, A11y folks and DPUB folks have talked about the need for semantically rich way of marking up notes
15:06:28 <azaroth> ... HTML is not good at this. Gathered some ideas a year ago and recently revised
15:06:52 <azaroth> ... Possible to do as an HTML extension. Can implement as what was called a web component
15:06:58 <uskudarli> uskudarli has joined #annotation
15:07:15 <azaroth> ... Revived the interest in that, put together a skeleton, and going to see if there's support in the IG to move forwards
15:07:38 <azaroth> TimCole: Would be nice to have that. There's a reference to the WAWG doc, so feedback would be welcome
15:07:51 <azaroth> ... Not sure if this relates to Doug's interest in HTML serialization issues
15:08:10 <azaroth> shepazu: Not sure if this is related or a separate branch. What I tried was very similar
15:08:33 <azaroth> TimCole: Other thing, the following week (May 2) has a discussion of WDs of our group
15:08:47 <azaroth> ... Rob and I will be on the call, and try to describe where we are
15:09:05 <PaoloCiccarese> PaoloCiccarese has joined #annotation
15:09:08 <azaroth> ... see if there's feedback on the drafts. Might be useful to have it before Berlin, so we can discuss any feedback
15:09:15 <azaroth> ... Ivan any thing else? (no)
15:09:22 <azaroth> ... Other announcements?
15:09:23 <TimCole> q?
15:09:36 <azaroth> TOPIC: Minutes Approval
15:09:40 <TimCole> PROPOSED RESOLUTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/15-annotation-minutes.html
15:10:04 <TimCole> q?
15:10:07 <azaroth> RESOLUTION: Minutes of the previous call are approved: https://www.w3.org/2016/04/15-annotation-minutes.html
15:10:43 <azaroth> TOPIC: Testing
15:10:58 <ivan> Regrets+ Ben_De_Meester
15:11:06 <azaroth> TimCole: First, need to get a sense of progress and what we need.
15:11:21 <azaroth> ... Can you review for the group, Shane?
15:11:35 <azaroth> ShaneM: We've done some thinking and there's some momentum to get the infrastructure in place
15:11:39 <TimCole> https://lists.w3.org/Archives/Public/public-annotation/2016Apr/0077.html
15:11:45 <shepazu> q+
15:11:46 <azaroth> ... But that's where we're at, haven't solved any problem yet
15:12:02 <azaroth> ... Talked with web platform tests to see if that's the right place, and it seems to be
15:12:06 <TimCole> https://github.com/Spec-Ops/web-platform-tests
15:12:17 <azaroth> ... The reason that was a question at all is that those tests are about exercising user agents
15:12:37 <azaroth> ... And components are not UA centric. So didn't want to violate principles, or step on toes
15:12:56 <azaroth> ... We can drive the testing from the browser, which is good, people used to running W3C tests will be familiar with interface
15:13:24 <azaroth> ... have set aside the question of is it possible to automate the testing of clients when selecting parts of documents
15:13:33 <azaroth> ... Can be manual intervention though
15:13:35 <PaoloCiccarese> Present+ Paolo_Ciccarese
15:14:00 <shepazu> conversation on public-test-infra https://lists.w3.org/Archives/Public/public-test-infra/2016AprJun/0000.html
15:14:04 <azaroth> ... For a given assertion, eg a MUST in the rec, that say the annotation takes a certain form
15:14:18 <azaroth> ... there's a couple of different ways to do it, but we can express tests in a declarative way with sample data
15:14:34 <azaroth> ... Select the region, run it through the client and push the data to make sure it has the right form
15:14:41 <azaroth> ... that sort of testing.
15:14:55 <azaroth> ... Don't think this is anything new, but we now have a model in mind and some people to put it together
15:14:59 <ivan> q+
15:15:08 <azaroth> ... There'll be some back end tooling for the web platform test environment
15:15:20 <azaroth> ... to support the declarative test cases
15:15:33 <azaroth> ... and a folder to put the tests in. Then running them is just select the folder and say run the tests
15:15:51 <azaroth> ... it'll run the automated ones for you. If you're a testing geek it's very interesting :)
15:16:03 <azaroth> ... I'll send out a mail to the group for an example test
15:16:27 <azaroth> ... Spec Ops has taken it on, as it's tightly coupled to the projects that we already have funded
15:16:31 <azaroth> ... was able to finesse it in
15:16:43 <azaroth> ... Don't have funding for annotation, but we need it elsewhere (Payments)
15:16:43 <TimCole> ack shepazu
15:17:13 <azaroth> shepazu: Another question came up... Shane's initial one was should we do client side testing
15:17:30 <azaroth> ... The testing methodologies for related things were like checking for self consistency and the shape of the data
15:17:59 <azaroth> ... Ontology/vocab specs has just been to test consistency, not the implementation
15:18:07 <azaroth> ... Exception for CSVW
15:18:13 <azaroth> ... Wanted to see what the feeling of the group was
15:18:15 <ShaneM> good question!
15:18:41 <azaroth> ... Should test what the user agents generate, but could be just is it consistent
15:18:50 <azaroth> ... Should we test both or just one?
15:19:04 <tilgovi> Yes
15:19:05 <tilgovi> Both
15:19:40 <azaroth> TimCole: The tests as described involve whether its consistent with the model
15:19:44 <ShaneM> Servers MUST be tested for the protocol spec.
15:19:46 <azaroth> ... but semantics harder to test
15:19:47 <bigbluehat> +1 to both
15:19:58 <shepazu> q+
15:19:59 <TimCole> ack ivan
15:20:04 <tilgovi> tilgovi has joined #annotation
15:20:41 <azaroth> ivan: One thing is that we have implementations, some are here in the group, that are not specifically browser based in the way that I understand the web platform to work
15:20:59 <azaroth> ... one of the differences might be that the media on which the annotations happen are not HTML but say images
15:21:15 <azaroth> ... we need the implementations, they're equally valid for the CR or should be, and whether that fits the testing model?
15:21:23 <ShaneM> it fits the model.
15:21:36 <azaroth> ... in some sense the extreme case, but perhaps for purely timing reasons, might have implementations that are part of an epub reader
15:21:53 <azaroth> ... have two, one mainly, but are completely out of the browser picture
15:22:09 <azaroth> ... Other question is that I presume this doesn't relate to the protocol testing?
15:22:38 <azaroth> ... Presume has to go through some different means?  And also, agree that both should be tested, but on a practical level if we have timing then the priority is the testing of the model
15:22:46 <bigbluehat> to be clear, all we can test is the Web Annotation Data Model serialization provided from the clients--where that JSON hits the testing code (browser, server, command line) is a matter of deployment
15:22:48 <azaroth> ... that's what's critical to have the CR phase complete
15:22:53 <ShaneM> ePub reader testing could be done here - but the connection between the ePub reader and the test environment is an exercise for the ePub reader implementor
15:22:55 <azaroth> ... Have to be careful on priorities
15:22:55 <TimCole> ack shep
15:22:59 <tilgovi_> tilgovi_ has joined #annotation
15:23:27 <azaroth> shepazu: There's a class of user agent that won't be able to use the test framework, so the tests themselves should run in both the platform and elsewhere
15:23:50 <azaroth> ... for those user agents that aren't browser based, we could do self reporting
15:23:59 <azaroth> ... need a validator that they send their output to
15:24:17 <azaroth> ... Here is the JSON-LD, I'll put it in this form for the test, and the test gets run
15:24:24 <azaroth> ... does that seem reasonable?
15:24:49 <ShaneM> q+ to mention that it would be possible to provide an endpoint on the web platform tests to which an ePub reader could push their annotation or whatever
15:24:56 <azaroth> ... if we should test the UAs, the spec is written so its largely about the vocab, not the UAs
15:25:04 <azaroth> ... not sure if we need a different spec to talk about what a UA should do
15:25:09 <azaroth> ... don't have a strong opinion
15:25:32 <azaroth> ... Could add normative assertions to the spec for conformance of UAs, which would help with testing
15:25:49 <bigbluehat> we can't test what isn't spec'd, and we haven't spec'd UA conformance and (under this current charter) we don't have time
15:25:50 <azaroth> ... maybe just at the beginning, UAs of this class, must do bla bla bla
15:25:55 <azaroth> ... then apply it to the different clients
15:26:12 <azaroth> ... recap existing assertions as applying to the generator of the content, rather than the model itself
15:26:30 <azaroth> scribenick: tilgovi
15:26:36 <bigbluehat> browser-based UA's won't have the same conformance requirements as a screen-scraper (for instance)
15:26:38 <TimCole> ack ShaneM
15:26:38 <Zakim> ShaneM, you wanted to mention that it would be possible to provide an endpoint on the web platform tests to which an ePub reader could push their annotation or whatever
15:27:16 <azaroth> q+ to describe image case
15:27:17 <tilgovi> ShaneM: if any epub reader implemented the protocol we couldprovide a testing endpoint
15:27:49 <tilgovi> ... the framework could open another endpoint for annotations
15:28:06 <tilgovi> ... we're going to put that framework together regardless
15:28:24 <tilgovi> ... your point is really good Doug, there's hardly any discussion of UA requirement sin the spec right now
15:28:29 <ivan> q+
15:28:32 <tilgovi> ... I don't have an opinion on whether the group shuold define these or not
15:28:55 <tilgovi> ... If you do, I encourage you to do it as a profile. They don't have to support all annotations, but they have to support them in the way you define it.
15:29:06 <tilgovi> ... You have a lot of different ways of using annotation.
15:29:23 <TimCole> ack azaroth
15:29:23 <Zakim> azaroth, you wanted to describe image case
15:29:32 <tilgovi> TimCole: Let's go forward in the queue for now.
15:29:56 <tilgovi> azaroth: Like the image case, it's not native in the browser, but I think what Shane's just described would work very well for our types of user agents
15:30:06 <tilgovi> ... if they implemented an early version of the protocol, they could relatively easily be updated
15:30:27 <tilgovi> ... we could add the validator endpoint as somewhere to send the annotations and have the validator run the tests that it thinks it can based on what it's received
15:30:41 <TimCole> ack ivan
15:30:47 <tilgovi> ... at least all of the syntactic validation should fit right in
15:31:04 <azaroth> s/if they/they/
15:31:15 <tilgovi> ivan: On the UA requirement, I am doubtful we can do something really useful and complete, at least in the lifetime of this working group.
15:31:41 <azaroth> +1 to Ivan -- priorities important, get what we need first, then nice to haves around different UAs
15:31:49 <bigbluehat> +1 to focusing on testing and shipping what we've already spec'd
15:31:58 <tilgovi> ... If I look at the various types of user agents, from Hypothesis to epub readers, we have too many and I don't think we can do a meaningful work on that so it would not be my priority in view of the time we have
15:32:26 <tilgovi> TimeCole: We talked before about grouping some of the features by things like media type as a way to have like profiles and acknowledged that no single implementation, as Shane mentioned, will do it all
15:32:34 <TimCole> q?
15:32:38 <tilgovi> ... is that what we talked about previously, Ivan?
15:32:40 <tilgovi> ivan: yeah.
15:33:10 <tilgovi> TimCole: Maybe other implementors on the call have thoughts.
15:33:24 <tilgovi> ... We talked a couple weeks ago about how we still need to do the work of identifying, in our documents, what are the testable features.
15:33:32 <tilgovi> ... I think we still have to do that.
15:33:39 <takeshi> q+
15:33:41 <tilgovi> ... Am I right?
15:34:02 <tilgovi> ShaneM: I believe you're correct. I know that I had an action to identify some things. I dind't do that and I apoligize.
15:34:17 <tilgovi> ... Greg Kellogg did do some of that, in the context of the discussions we were having.
15:34:28 <tilgovi> ... Showing how we much craft a declarative test.
15:34:35 <Loqi> gregg has 1 karma
15:34:38 <tilgovi> s/much/might/
15:34:54 <tilgovi> ... You use a declarative grammar to say "this is what is to be tested" and then you write a framework that is the script
15:35:02 <azaroth> q+ to ask about automation of declarations from ontology
15:35:22 <tilgovi> ... We are looking for the possibility that anyone can write a test. Since the declarative grammar is JSON and you are all very familiar we JSON that's one fo the reasons we're looking at this route.
15:35:23 <bigbluehat> here's the draft from gregg https://gist.github.com/gkellogg/4ff74c27313e95a6b3dcbad6cc64277a
15:35:30 <tilgovi> ... There's a gist he put up. Thank you, Benjamin.
15:35:54 <tilgovi> ... I hadn't planned to go through this because it's embryonic, we just started the work.
15:36:02 <bigbluehat> it's 75% JSON Schema fwiw
15:36:17 <tilgovi> ... If you follow that link, the test is the input about the test that defines the context and the annotation. It's the input for a test.
15:36:35 <ivan> q+
15:36:38 <tilgovi> TimCole: Maybe if people look at that you can get more people to help find and make those declarative tests about the assertions.
15:37:04 <tilgovi> ShaneM: Yes. If we can get a few examples, hopefully we can cut up the spec and one person can go off and look at a section and add these testable assertions
15:37:06 <bigbluehat> advantage of declarative is that we can use them in the browser, via the command line, or an API
15:37:16 <TimCole> ack takeshi
15:37:21 <tilgovi> TimCole: In the interest of times, I'd like to wrap this discussion up for the day, in ten minutes or so.
15:37:47 <tilgovi> takeshi: I'm implementing a sort of annotation application as a prototype and that is a native application, not based on the browser engine.
15:37:59 <tilgovi> ... Since we are focusing on handwriting, the text selection is in second priority.
15:38:20 <tilgovi> ... Even if we receive the text selection annotation from the server it might be ignored or just show up as an annotation to that web page.
15:38:34 <tilgovi> ... That could be different from the expectation for others, but at this time this is what I am planning to do.
15:38:58 <tilgovi> ... If the specification requires that any of the feature has to be implemented in the annotation application, I'm afraid that my application could not meet that criteria.
15:39:55 <tilgovi> TimCole: Would you application be able to send annotations that you generate as JSON-LD to a validator.
15:40:25 <tbdinesh> how do you test if a feature (such as selection) is implemented in an annotation appl?
15:40:28 <TimCole> ack azaroth
15:40:28 <Zakim> azaroth, you wanted to ask about automation of declarations from ontology
15:40:31 <tilgovi> takeshi: Even though all the annotation data will be sent in the JSON-LD, we might ignore some annotations we have in JSON-LD
15:41:24 <tilgovi> azaroth: Many of the requirements are in the vocabulary with which properties they should be used with and whether you can have more than one, etc
15:42:08 <tilgovi> ... It may be useful if we create at least stubs of all of the possible tests going forward, and workin with the IDPF to make the JSON schema ... there's a lot of shared tooling around what sorts of tests can be written given the flexibility of RDF and JSON-LD, but still keeping it within the spec.
15:42:24 <tilgovi> ... Question then is, is that something that we should look into? I'm happy to spend a bit of time working on it.
15:42:29 <tilgovi> ShaneM: That would be fantastic.
15:43:01 <tilgovi> ... We envisioned doing certain kinds of exercising automatically. We have some tooling for that, but let's not monopolize this meeting.
15:43:04 <TimCole> ack ivan
15:43:22 <tilgovi> ivan: Rob almost said everything I wanted to say. I have one additional thing to add.
15:43:35 <tilgovi> ... I think having JSON Schema around as an additional tool we give to current and future implementors would be useful anyway.
15:43:49 <tilgovi> ... We can have an informative reference on the website alongside the context file.
15:43:51 <TimCole> q?
15:44:06 <tilgovi> ShaneM: Obviously, JSON Schema is much more restrictive in terms of structure than JSON-LD, but that's okay.
15:44:30 <tilgovi> TimCole: I don't think I heard any formal actions, but clearly members need to look at how these assertions and testable features are expressed in a declarative way and think about how to contribute to that.
15:44:38 <tilgovi> ... The JSON schema would be useful.
15:44:45 <tilgovi> ... And we have the potential automating of some of the tests.
15:44:54 <tilgovi> ... We probably need to think about timeline for getting these things done.
15:45:05 <ShaneM> Here is my ask: Anyone who wants to be looped in, go to http://lists.spec-ops.io/listinfo.cgi/testdev-spec-ops.io and join the list
15:45:12 <tilgovi> ... Can I suggest we make it of prime importance for next weeks call to think about what we want to get done before the face to face.
15:45:21 <ShaneM> and yes - let's set a schedule in the next week
15:45:25 <tilgovi> ... Does that sound like a way forward? Did I miss something important?
15:45:48 <TimCole> Topic: Issues
15:46:19 <tilgovi> TimCole: Issue #200 was should oa:start and oa:end always use xsd:nonNegativeInteger.
15:46:23 <TimCole> https://github.com/w3c/web-annotation/issues/200
15:46:39 <tilgovi> ... I think we talked about lat week that this proposal was the way to do it. The answer was yes. We wanted to give people a chance to think about it for a week.
15:46:43 <tilgovi> ... Do we need further discussion on this?
15:46:59 <tilgovi> azaroth: I think we can make it an editorial action to update the context.
15:47:23 <tilgovi> ... The concern that I had that stain proved was not a concern, whether or not JSON-LD compaction causes nonNegativeInteger to stick around.
15:47:29 <EmrahGuder> EmrahGuder has joined #annotation
15:48:04 <azaroth> PROPOSED RESOLUTION: Accept git issue #200, make start and end nonNegativeInteger in @context
15:48:06 <ivan> +1
15:48:07 <azaroth> +1
15:48:07 <PaoloCiccarese> +1
15:48:10 <TimCole> +1
15:48:20 <tbdinesh> +1
15:48:22 <takeshi> +1
15:48:26 <davis_salisbury> +1
15:48:27 <ShaneM> I am abstaining - too new here
15:48:30 <tilgovi> I can't reproduce the success described.
15:48:36 <tilgovi> With compaction removing it.
15:49:35 <ivan> rrsagent, pointer?
15:49:35 <RRSAgent> See http://www.w3.org/2016/04/22-annotation-irc#T15-49-35
15:49:37 <azaroth> RESOLUTION: Accept git issue #200, make start and end nonNegativeInteger in @context
15:49:47 <TimCole> https://github.com/w3c/web-annotation/issues/203
15:50:19 <tilgovi> TimCole: The discussion last week on selectors vs media types, there was a lot of positive response about what's been put together.
15:50:41 <tilgovi> ivan: I think the idea that came out of some discussion was that this table should exist, so I sat down on made it. I think it should go back to the editors to look at.
15:50:52 <tilgovi> ... There are comments I made in the issue, but I think they are all editorial.
15:51:15 <tilgovi> ... I would propose this is something Benjamin, Rob, and I can handle on email.
15:51:20 <azaroth> +1 with a few minor tweaks (e.g. Fragment should be either tick or ?, as we don't know future fragment specs and don't want to suggest they're not to be used)
15:51:39 <tilgovi> TimCole: So a proposal would be to put this to editor action.
15:52:02 <azaroth> PROPOSED RESOLUTION: Accept proposed media/selector table towards conformance section of the specs
15:52:06 <azaroth> +1
15:52:08 <TimCole> +1
15:52:09 <ivan> =1
15:52:11 <ivan> +1
15:52:18 <PaoloCiccarese> +1
15:52:32 <takeshi> +1
15:52:46 <azaroth> RESOLUTION: Accept proposed media/selector table towards conformance section of the specs
15:52:57 <TimCole> https://github.com/w3c/web-annotation/issues/195
15:52:58 <ivan> rrsagent, pointer?
15:52:58 <RRSAgent> See http://www.w3.org/2016/04/22-annotation-irc#T15-52-58
15:53:03 <tilgovi> TimCole: Let's take one more issue today.
15:53:11 <tilgovi> ... this was the issue involving refining state by selector.
15:53:28 <tilgovi> ... As I understood the thread, there's some confusion about what is needed here.
15:54:22 <tilgovi> ivan: There is a question if I can mix, with some limitations, the refinements. Can I refine a state with a selector?
15:54:34 <tilgovi> ... I have the impression that there is no disagreement on that between us.
15:54:48 <tilgovi> azaroth: There are no disagreements on that. It would be good to be able to refine a state with a selector.
15:55:07 <tilgovi> ivan: I would propose to do that, then, and let that be an editorial action.
15:55:21 <PaoloCiccarese> q+
15:55:26 <tilgovi> azaroth: To be clear, where we may disagree, I think it should still be possible to have both hasState and hasSelector on a specific resource.
15:55:33 <tilgovi> ivan: I'm saying I'd like to separate these two questions.
15:55:47 <tilgovi> TimCole: Can we do that? Can a new issue be created and some resolution be posted to the issue to Github.
15:55:54 <tilgovi> ... in the meantime we can close the other issue.
15:56:03 <PaoloCiccarese> q-
15:56:12 <tilgovi> ivan: I think that the issue is saying, can a refinement be made on a state?
15:56:20 <tilgovi> ... we can make that a sepraate issue and make it editorial right away.
15:57:02 <tilgovi> TimCole: I want to give people a chance over the week before we actually close it out.
15:57:02 <TimCole> https://github.com/w3c/web-annotation/issues/147
15:57:21 <tilgovi> TimCole: We don' thave time to talk about HTML serialization in depth, we don't have time, but there was discussion in 147
15:57:46 <tilgovi> ... about the challenges in that RDFa people will be using different labels because you don't have the context available in RDFa that we have in JSON-LD.
15:57:50 <tilgovi> ... Do we need to talk about this?
15:58:20 <PaoloCiccarese> +1 to the namespace
15:58:48 <tilgovi> ivan: To have that namespace document before the end of the WG is probably a good idea.
15:59:05 <tilgovi> ... I can look at doing it, or someone else can. At this moment I cannot do it and I think it should not have a high proiority for the coming weeks.
15:59:22 <ivan> q+
15:59:29 <tilgovi> TimCole: Let's leave it in there and we'll get to it after Berlin, I guess.
15:59:52 <TimCole> ack ivan
15:59:54 <tilgovi> ivan: A question to Rob.
16:00:14 <tilgovi> ... Rob, I am in a complete mess right now... what happens to the vocabulary file and the context file that should be pushed on to /ns?
16:00:26 <tilgovi> ... I haven't done anything on installing it on the W3C side because I have no idea where we are.
16:00:31 <tilgovi> azaroth: I'm in the same state, I must admit.
16:00:39 <tilgovi> ivan: At some point we have to do that. We are already out of sync.
16:01:11 <tilgovi> ... By the time we go to CR, when tests become available, these things should be in sync.
16:01:18 <tilgovi> TimCole: Anything else?
16:01:24 <tilgovi> ... Thanks, everybody. We'll talk next week.
16:01:35 <tilgovi> tilgovi has left #annotation
16:01:49 <ivan> rrsagent, draft minutes
16:01:49 <RRSAgent> I have made the request to generate http://www.w3.org/2016/04/22-annotation-minutes.html ivan
16:01:57 <ivan> trackbot, end telcon
16:01:57 <trackbot> Zakim, list attendees
16:01:57 <Zakim> As of this point the attendees have been Rob_Sanderson, TimCole, Tim_Cole, ShaneM, Ivan, Benjamin_Young, Randall_Leeds, tb_dinesh, davis_salisbury, Takeshi_Kanai, Paolo_Ciccarese
16:02:05 <trackbot> RRSAgent, please draft minutes
16:02:05 <RRSAgent> I have made the request to generate http://www.w3.org/2016/04/22-annotation-minutes.html trackbot
16:02:06 <trackbot> RRSAgent, bye
16:02:06 <RRSAgent> I see no action items