16:05:22 <RRSAgent> RRSAgent has joined #annotation
16:05:22 <RRSAgent> logging to http://www.w3.org/2015/04/22-annotation-irc
16:05:24 <trackbot> RRSAgent, make logs public
16:05:25 <TimCole> TimCole has joined #annotation
16:05:25 <Zakim> Zakim has joined #annotation
16:05:26 <trackbot> Zakim, this will be 2666
16:05:27 <trackbot> Meeting: Web Annotation Working Group Teleconference
16:05:27 <trackbot> Date: 22 April 2015
16:05:28 <Zakim> I do not see a conference matching that name scheduled within the next hour, trackbot
16:05:53 <fjh> Chair: Frederick_Hirsch, Rob_Sanderson
16:05:57 <RayD> RayD has joined #annotation
16:06:03 <fjh> Present+  Frederick_Hirsch, Rob_Sanderson
16:06:11 <TimCole> Present+ Tim_Cole
16:06:12 <RayD> present+ Ray_Denenberg
16:06:13 <tilgovi> Present+ Randall_Leeds
16:06:25 <takeshi> takeshi has joined #annotation
16:06:36 <fjh> Agenda: https://lists.w3.org/Archives/Public/public-annotation/2015Apr/0118.html
16:06:47 <azaroth> TimCole: http://w3c.github.io/web-annotation/protocol/wd/
16:06:47 <fjh> fjh has changed the topic to: agenda https://lists.w3.org/Archives/Public/public-annotation/2015Apr/0118.html
16:07:00 <nickstenn> nickstenn has joined #annotation
16:07:09 <nickstenn> present+ Nick_Stenning
16:07:19 <paoloC> paoloC has joined #annotation
16:07:19 <fjh> 1. Introduction, Scribe Selection, Announcements, etc
16:07:20 <fjh> Annotations at Europeana
16:07:22 <fjh> 2. Minutes approval
16:07:23 <fjh> 3. Client API
16:07:25 <fjh> Frederick to start, followed by implementation lessons and ideas (e.g. Hypoothes.is Nick et al), discussion
16:07:26 <fjh> break
16:07:28 <fjh> 4. LDP Recap
16:07:29 <fjh> 5. Protocol - update, next steps, FPWD?
16:07:31 <fjh> lunch
16:07:32 <fjh> 6  robust anchoring, find
16:07:34 <fjh> break
16:07:35 <paoloC> Present+ Paolo_Ciccarese
16:07:35 <fjh> 7 search
16:07:36 <fjh> 8 additional use case discussion - footnotes, web packaging, publishing  etc
16:07:37 <ujvari_> present+ Gergely_Ujvari
16:07:37 <fjh> 9 Data model issue review
16:07:38 <fjh> 10 other business
16:07:39 <fjh> ScribeNick: tilgovi
16:08:05 <csillag1> present + Kristof_Csillag
16:08:05 <fjh> Topic: Welcome, Agenda Review, Announcements
16:08:17 <fjh> am Randall scribe then Tim
16:08:30 <takeshi> Present+ Takeshi_Kanai
16:09:24 <tbdinesh> tbdinesh has joined #annotation
16:11:45 <tilgovi> Dan Whaley: with Hypothesis
16:11:51 <tilgovi> Kristof Csillag: with Hypothesis
16:12:00 <tilgovi> Gergely Ujvari: with Hypothesis
16:12:18 <tilgovi> Takeshi Kanai: I'm Takeshi Kanai, with Sony
16:12:57 <azaroth> Rob Sanderson, Stanford, co-chair with Frederick, co-editor with Paolo on the model, editor for protocol (and happy to have a co-editor :) )
16:12:58 <tilgovi> I am interested in implemneting the outcomes for this device (holding tablet device)
16:13:17 <tilgovi> We are trying to also read Web documents on this device
16:13:34 <tilgovi> Randall Leeds: I'm Randall Leeds, also with Hypothesis
16:13:43 <tilgovi> Jon Udell: I'm Jon Udell, also with Hypothesis
16:13:45 <fjh> Present+ Jon_Udell
16:14:08 <RayD> Ray Denenberg, Library of Congress
16:14:11 <tbdinesh> .present +TB_Dinesh
16:14:49 <TimCole> Tim Cole (TimCole), University of Illinois and a founding member of the Open Annotation Community Group
16:14:57 <fjh> Present+ Phil_Desenne_(Harvard_Observer)
16:15:00 <tilgovi> Phil_Desenne: I'm Phil Desenne with Harvard University
16:15:02 <fjh> Presnt+ Tim_Cole
16:15:23 <tilgovi> bigbluehat: I'm Benjamin Young, I'm with Hypothesis. I like APIs.
16:15:44 <fjh> Annotations at Europeana
16:15:45 <tbdinesh> present +TB_Dinesh
16:16:23 <fjh> https://lists.w3.org/Archives/Public/public-annotation/2015Apr/0103.html
16:16:30 <tilgovi> TimCole: There are a number of different people working on different pieces. There has been annotation in Europeana previously, but there seems to be a
16:17:27 <tilgovi> scribe: tilgovi
16:18:15 <TimCole> There seems to be a new push to bring annotaation into the core of Europeana, which is good; glad they're paying attention.
16:18:16 <tilgovi> fjh: Ivan is not here, but there's this whole space of ebook related stuff that maybe we should address and other thinsg that we need to revisit that we haven't done
16:18:36 <tilgovi> Does anyone else have anything to offer the agenda?
16:19:10 <TimCole> q+
16:19:16 <fjh> ack TimCole
16:19:21 <tilgovi> TB asked how this comes together with other things like social but I think we have a pretty full agenda
16:20:34 <tilgovi> bigbluehat: I wanted to know who was here yesterday. The social web is looking at SOLiD, a social web linked data thing. I wanted to know if it came up at all.
16:21:25 <tilgovi> ... the social WG is looking at several different protocols, but SOLiD seems to have a lot of iteration and the most overlap with us because it's LDP
16:21:37 <tilgovi> fjh: We're going to move on now, to the LDP recap
16:21:46 <fjh> Topic: LDP recap
16:22:12 <tilgovi> azaroth: yesterday there was a meeting of the LDP WG, about the same number as here today
16:22:41 <tilgovi> ... including foo from IBM and bar from Oracle, as well as myself and Dinesh and Takeshi
16:22:56 <tilgovi> ... main work was finding out the status of what everybody is doing
16:23:19 <fjh> Patch
16:23:21 <tilgovi> ... relevant bits for us, the LD PATCH work is
16:23:45 <tilgovi> ... to send updates to a resource rather than completely overwriting it, like SPARQL update and JSON PATCH and diffs
16:24:04 <bigbluehat> SoLiD API proposal (based on LDP) from the Social Web WG: https://github.com/linkeddata/SoLiD
16:24:05 <tilgovi> ... but for linked data, where we might have blank nodes, and other things
16:24:11 <tilgovi> ... that has all the boxes checked to go through to technical recommendation
16:24:19 <tilgovi> ... However, the third part, LD Paging, does not
16:24:39 <tilgovi> ... At the moment, there's only one implementation, and the framework for a test suite
16:24:49 <bigbluehat> Present+ Benjamin_Young
16:24:50 <tilgovi> ... but needs a second implementation and test implementation to demonstrate interpo
16:24:53 <shepazu> shepazu has joined #annotation
16:25:02 <TimCole> TimCole has joined #annotation
16:25:04 <tilgovi> ... The status at the moment is that it would be published as a WG note, rather than a TR
16:25:29 <fjh> q+
16:25:39 <tilgovi> ... If we want to make normative references to that, if we as a WG think that's the right way to go for paging through sets of annotations, that would help us a lot in the future because then it could be a TR that we could refer to
16:26:04 <tilgovi> ... The other thing addressed was the rechartering process. We tried to gauge interest in the different topics that had come up for a second round of work.
16:26:39 <tilgovi> ... The topics that were most interesting were discovery (of containers, endpoints), which we need here, and extensiblility, so if there were a new capability that a server implemented there might be a way to link to that documentation of what it can do
16:26:56 <tilgovi> ... There was a lot of discussion about filtering and query, which we've been discussing here as well, and it's promising that that is ranked highly
16:27:00 <tilgovi> ... The third area was access control
16:27:25 <fjh> q-
16:27:27 <tilgovi> ... Seems like all of the LDP 1.1 focus would help us in the Annotation WG
16:27:39 <fjh> q+ to ask about benefit of referencing LDP, interop benefits, risks
16:27:44 <tilgovi> ... Unnerving issue is that the current chair cannot commit to being a chair in the future WG, so we would need to find a new chair before we could continue
16:28:13 <fjh> q?
16:28:18 <fjh> ack fjh
16:28:18 <Zakim> fjh, you wanted to ask about benefit of referencing LDP, interop benefits, risks
16:28:33 <tilgovi> fjh: I've been asking myself "what is the benefit/risk of having a dependency on LDP?"
16:28:43 <tilgovi> ... if what we're deploying is mostly just some REST then what do we get
16:28:49 <tilgovi> ... my understanding is that some of what's in LDP we don't need
16:29:01 <tilgovi> ... my suspicion is that if paging is a note there will be no interop testing
16:29:10 <tilgovi> ... so we have to make interop testing for that
16:29:44 <tilgovi> azaroth: For the basic containers there is a test suite and we would be able to bridge a lot of tests and implementations
16:30:09 <tilgovi> ... I think it's worthwhile. Especially on the last call, we discussed that paging may simply fall out naturally from querying or relate more strongly to paging than the general LDP paging
16:30:29 <tilgovi> ... other advantage is that we wouldn't need to specify all of the base level interactions like what is PUT, POST, etc
16:30:43 <tilgovi> ... Really just a profile of that where what you're seeing is an annotation
16:30:44 <fjh> q?
16:30:52 <JakeHart> Present+ Jake_Hartnell
16:31:12 <tilgovi> fjh: if it hadn't been done, I would be concerned about creating a dependency if we were going to do it anyway
16:31:17 <azaroth> azaroth has joined #annotation
16:31:17 <fjh> q?
16:31:46 <bigbluehat> q+
16:31:47 <tilgovi> shepazu: because this isn't my area (that part of the stack) I'm not really comfortable knowing if LDP and ActivityStreams... where they overlap, compete, etc
16:31:54 <fjh> q+
16:32:02 <tilgovi> ... I know there were people who attended the annotation workshop from the US gov't who said 'we have to do ActivityStreams'
16:32:20 <tilgovi> ... is ActivityStreams in the same space as LDP or not?
16:33:02 <tilgovi> fjh: There were three ways social was looking at doing protocol, LDP, ActivityStreams, and Micropub, so the LDP stuff would be a profile like what we're doing
16:33:07 <tilgovi> ... I'm not familiar with SOLiD
16:33:25 <tilgovi> bigbluehat: SOLiD spun out of the last Social WG F2F, possibly mixing in some SPARQL stuff
16:34:13 <tilgovi> fjh: I thought micropub was the one that had legs in the group
16:34:28 <tilgovi> bigbluehat: the group is pretty fractured, but micropub has an achilles heel because it has no JSON-LD semantics
16:34:38 <tilgovi> ... so you would have to map it to an ActivityStreams output
16:35:12 <tilgovi> ... whereas the LDP-based one is JSON-LD, is AS2.0 ... James Snell has an implementation, and then there's SOLiD which pulls in other things
16:35:25 <tilgovi> ... James' stuff is just LDP + AS2.0, but both use AS2.0 as currently written
16:35:28 <fjh> q?
16:35:44 <tilgovi> ... the other two have no knowledge of AS2.0, so there's a whole lot more work to do to map it to the document that's been made so far
16:35:51 <tilgovi> fjh: what is the time frame fro SOLiD?
16:35:56 <tilgovi> bigbluehat: they are having a F2F in May in Paris.
16:36:05 <tilgovi> ... that was stuck on the board as a deadline for a fleshed out presentation
16:36:17 <fjh> q-
16:36:20 <tilgovi> ... they're getting decent iteration of it
16:36:42 <tilgovi> Zakim: who's here?
16:36:49 <fjh> q-
16:36:56 <fjh> q-
16:37:09 <fjh> Topic: Client API
16:37:21 <bigbluehat> q-
16:37:52 <tilgovi> fjh: we have a bunch of stuff in our charter, some stuff we haven't talked about much
16:37:58 <tilgovi> ... so one of the ideas for this F2F is to get those things moving
16:38:04 <judell_> judell_ has joined #annotation
16:38:10 <tilgovi> ... one of the topics is the client side API, we should talk about what we're trynig to do and what the assumptions are
16:38:36 <tilgovi> .. I think we're talking about JavaScript using Web IDL
16:38:43 <tilgovi> ... I think we're talking about JavaScript using Web IDL
16:38:53 <tilgovi> ... The reality is that it just goes to JS now, but we still use it all over the W3C anyway
16:39:05 <tilgovi> ... but that's what I think script interface means... JS described by Web IDL
16:39:09 <tilgovi> ... events means HTML5 Events
16:39:20 <tilgovi> ... "in a browser" means we're talking about asynchronous interfaces that probably use Promises
16:39:39 <bigbluehat> s/foo/Arnaud Le Hors
16:39:56 <tilgovi> ... reading system is another item in the list
16:40:06 <tilgovi> ... I think that means we want support for offline and synchronization, but we should talk about how far we have to go in that work
16:40:15 <tilgovi> ... I'm not sure what a plugin means except that it's an incremental deployment strategy
16:40:23 <tilgovi> ... to do the implemnetations without getting browser buy-in immediately
16:40:45 <tilgovi> ... So what's the core functionality of the API?
16:40:57 <tilgovi> ... I think it includes some basics that are similar to the protocol but it's not the protocol
16:41:11 <tilgovi> ... I don't think Social WG has a client protocol in the same way, so when they say Client API they mean the protocol
16:41:24 <tilgovi> ... We want to allow to do things in a client application, something different from but integrated with the protocol
16:41:44 <tilgovi> ... I think you're working with the JS in the page you're at, which has security implications
16:41:49 <shepazu> q+
16:41:58 <tilgovi> ... Doug has work on a robust anchoring API, we'd probably want to integrate with that
16:42:09 <tilgovi> ... Local caching seems important, whether it's in the API, I don't know
16:42:32 <tilgovi> ... The authentication, OAuth, seems important, I don't know if it's ours but maybe we have to make recommendations
16:42:38 <tilgovi> ... then search, which is probably an API method as well
16:43:01 <tilgovi> fjh: We have to do sensible HTML5 integration, which means a bunch of best practices for writing APIs
16:43:22 <bigbluehat> on the earlier API note, here's James Snell's LDP-based ActivityStreams API code: https://github.com/jasnell/dandus
16:43:43 <tilgovi> ... you shuold be able to have a server-side implementation and still do stuff, a client api is not required in that sense
16:44:25 <tilgovi> ... I was thinking about the IndieWeb work and noting the requirements there about server software simplicity, but I think this doesn't impact the client API
16:44:51 <tilgovi> ... There's a lot of stuff going in with privacy in different W3 groups, and one thing that has emerged over the years is the idea of user control
16:45:12 <tilgovi> ... sharing with the server expectations about retention and re-use of data
16:45:20 <tilgovi> ... we might want an extension point but I'm not sure we need to do much
16:45:31 <tilgovi> ... Do we need to say anything about UI implementation support in the API?
16:45:41 <tilgovi> ... Do there need to be methods to help associate CSS stuff with the presentation?
16:45:53 <tilgovi> ... Do we need to integrate with social? I think it's beyond what we need to worry about at the beginning.
16:46:27 <tilgovi> fjh: There's a list of requirements in a document from paoloC that might also apply to the API
16:47:13 <tilgovi> ... What's the target URI, path, we have to be able to make these statements in the API
16:47:35 <tilgovi> ... I'm hoping this will dovetail a bit with what nickstenn has been thinking about
16:47:36 <fjh> https://lists.w3.org/Archives/Public/public-annotation/2015Apr/att-0121/ClientSideAPI.pdf
16:47:38 <fjh> q?
16:47:42 <azaroth> Link to the requirements from DPUB use cases: http://www.w3.org/TR/dpub-annotation-uc/#requirements
16:48:11 <tilgovi> nickstenn: to be clear, I don't have a slide show that answers any of the questions that fjh just asked
16:48:25 <tilgovi> ... this is not a piece of work with hours of investment, but it's a thing we've been playing with on and off at Hypothesis
16:48:30 <tilgovi> ... it's one piece of what we're talking about
16:49:00 <nickstenn> https://docs.google.com/presentation/d/1ZKSZyLbEFqwYaG32cFJwcXQjjiU2ZzQguDmyhKfaTdY/edit#slide=id.p
16:49:42 <tilgovi> nickstenn: What I'm going to talk about is a little project that came out of questions around how we make Annotator part of an interoperable ecosystem and part of the work doing here rather than doing its own thing
16:50:03 <tilgovi> ... this component is supposed to answer, "What is the smallest, useful, low-level component in a client-side API for annotation?"
16:50:17 <tilgovi> ... I'm talking about something that might be useful across different applications but is not expansive in scope
16:50:31 <tilgovi> ... when we say "client side" API we envision something that would ultimately be used in JS from the DOM APIs
16:51:04 <tilgovi> ... by "low-level" we mean that standardized APIs in clients should be lower-level than you might at first think, because it's less likely that you'll build something wrong even if other people have to do more work to make it more useful
16:51:12 <azaroth> +1 to nickstenn
16:51:18 <tilgovi> ... but if you give something higher level where there isn't access to the nuts and bolts it may end up not getting used
16:51:45 <tilgovi> ... What I mean by 'annotation application' I mean some piece of software that creates annotations, whether the user sees it that way or not
16:51:53 <tilgovi> ... for example, it could be the code that Medium uses to create annotations
16:52:02 <tilgovi> ... it could be an extension that lets you see who is tweeting about the current document
16:52:21 <tilgovi> ... the point is that the state of the annotation applications lives with them (in this diagram)
16:52:33 <tilgovi> ... DOM Annotations is supposed to be a layer over the document where the current state of annotations on the document can live
16:52:47 <tilgovi> ... the idea being that the application(s) can use that and potentially see the annotations created by other annotation applications
16:53:12 <tilgovi> ... When I say "state", I am specifically talking about the state of annotations attached to a document at a current point in time in a given "page load"
16:53:21 <tilgovi> ... Not storage, not retreiveal, not persistence
16:53:29 <tilgovi> s/retreiveal/retrieval/
16:53:39 <tilgovi> nickstenn: This is like when you open the inspector and see the styles and dom elements
16:54:20 <tilgovi> ... as a developer, you might ask, "How do I attach annotations to (parts of) the document?", "How do I retrieve annotations associated with (same)?"
16:54:37 <tilgovi> ... and, to riff on what fjh said, most HTML APIs are event based
16:54:51 <tilgovi> ... so, "How can I be notified when annotations are attached/changed/removed" even by pieces of software I don't control
16:54:56 <tilgovi> ... DOM Annotations tries to answer some of these questions
16:55:20 <JakeHart> https://github.com/nickstenning/domannotations
16:55:21 <tilgovi> ... "straw man" proposal, pick holes in it: https://github.com/nickstenning/domannotations
16:55:32 <tilgovi> nickstenn: This is all it is, it's not large
16:55:47 <tilgovi> ... currently implemented as a polyfill, in the sense that you load a library and it attaches stuff to existing pieces of the DOM API
16:55:53 <tilgovi> ... it is intended to mimic existing APIs
16:56:03 <tilgovi> ... one of my questions is: "is that a good idea"
16:56:08 <fjh> q?
16:56:13 <fjh> q+
16:56:16 <tilgovi> ... some argument from consistency says "yes" but whether that's the best practices at this point is not clear
16:56:27 <tilgovi> ... Three functions on the document object (we can argue about whether that's the right thing):
16:56:32 <tilgovi> ... createAnnotation(), no arguments
16:56:53 <tilgovi> ... as document.createElement() creates an element but doesn't attach it to the document, this is essentially just a constructor
16:57:08 <tilgovi> ... getAnnotations(), at the moment takes an array of Nodes, is the querying part
16:57:09 <fjh> q-
16:57:14 <tilgovi> ... it asks what annotations are attached to the nodes
16:57:16 <fjh> q+ to ask about server integration
16:57:19 <tilgovi> ... lastly, removeAnnotation() is probably fairly obvious
16:57:31 <tilgovi> ... In the current implementation, Annotations are first class objects just as Nodes and Elements are
16:57:38 <tilgovi> ... At the moment, they don't do anything interesting, just enough to work
16:57:50 <tilgovi> ... they have two methods, addTarget() and addBody()
16:58:27 <tilgovi> ... Targets are also, currently, first-class objects you must, yourself, construct that reference parts of the DOM
16:58:44 <tilgovi> ... If you are familiar with the Range APIs...
16:58:53 <tilgovi> ... a "Text" target might be a wrapper around a Range
16:59:10 <tilgovi> https://dom.spec.whatwg.org/#ranges
16:59:23 <tilgovi> nickstenn: There are also some events: 'annotation{create,change,remove}'
16:59:51 <tilgovi> ... these are fired on the Document
17:00:06 <tilgovi> ... 'annotationcreate', it's worth noting, at that point nothing is attached and there is no data for the annotation
17:00:17 <tilgovi> ... 'annotationchange' says it changed, someone added a target / removed a target, etc
17:00:38 <tilgovi> shepazu: At that point, would the event bubble or would it simply be on the Document?
17:00:45 <tilgovi> nickstenn: At the moment it's simply on the Document
17:00:56 <tilgovi> ... the first time I did this I made it bubble, but there are problems we can discuss with that
17:01:03 <tilgovi> ... 'annotationremove' is probably straightforward
17:01:18 <tilgovi> fjh: I assume this means that I could have an event handler, and then update the server if I want persistent storage
17:01:27 <tilgovi> ... so the event model is elegant in allowing you to do these things as you see fit
17:01:29 <tilgovi> nickstenn: precisely
17:01:43 <tilgovi> TimCole: so if I remove it, I'm removing it from "this document" and it says nothing about what's happening on a server
17:01:54 <tilgovi> nickstenn: Yes. There is a distinction between change and remove vs update and delete.
17:02:10 <tilgovi> ... change and remove happen within the document, but update and delete are user actions with effects elsewhere
17:02:18 <tilgovi> ... it may well be that removal denotes that you want to delete it, but it may not
17:02:53 <tilgovi> shepazu: conversely, if someone made an annotation, remotely, and they delete it, it wouldn't be removed in your local notification
17:03:00 <tilgovi> s/notification/document/
17:03:02 <fjh> q?
17:03:09 <tilgovi> azaroth: as well as the persistence layer, you would need this for the user interface layer
17:03:27 <tilgovi> nickstenn: some of these discussions we might want to have more informally
17:03:45 <tilgovi> ... "how would you write a persistence module that watches these events and saves annotations elsewhere"
17:04:01 <tilgovi> ... "how would a user interface module that wants to draw highlights on the page and remove them"
17:04:11 <tilgovi> fjh: I like that it's simple and it's consistent with what I've seen about events
17:04:36 <tilgovi> ... is Server Sent Events a rec?
17:05:01 <tilgovi> nickstenn: Again, that is something you as an implementor might integrate with this API to handle events from a server
17:05:11 <tilgovi> ... <demo>
17:05:49 <bigbluehat> Server Sent Events specification: http://www.w3.org/TR/eventsource/
17:06:03 <bigbluehat> EventSource is the browser-side API name for dealing with Server Sent Events
17:06:29 <tilgovi> nickstenn: When I select text, I use the same methods to detect the selection that I do in Annotator
17:06:37 <tilgovi> ... but then I create an annotation (using the createAnnotation API)
17:07:00 <tilgovi> ... The highlighter, though, is a separate component, that listens to the annotationchange event and enumerates the targets and draws some highlights
17:07:14 <tilgovi> ... At the moment, this is a polyfill, so it's kind of a hack on a stick, so they are DOM CustomEvents
17:07:22 <tilgovi> ... this would be something we actually specify in WebIDL
17:08:11 <tilgovi> ... when I click on a node, I'm using the getAnnotations API to get the annotations on that node
17:08:16 <tilgovi> ... and then using the removeAnnotation to remove the annotations
17:08:28 <tilgovi> ... the highlighter then listens to the annotationremove event, and removes the highlight
17:08:33 <bigbluehat> text/event-stream is the Media Type for the text format sent from the server: http://www.w3.org/TR/eventsource/#text-event-stream
17:08:48 <tilgovi> shepazu: With the getAnnotations, let's say there are two annotations that are on a particular span
17:08:56 <tilgovi> ... what if I wanted to get all the annotations on a particular section?
17:09:02 <tilgovi> q+
17:09:12 <tilgovi> ... the node that i'm clicking on has annotations with it as its target
17:09:20 <tilgovi> ... does it also work for getting all annotations within a node
17:09:28 <TimCole> q+
17:09:46 <tilgovi> nickstenn: what you have described is "given a node, show me the annotations" but a lot of real world applications might want "given a chunk of the document, give me all the annotations"
17:09:58 <tilgovi> ... I think the answer to that is that it's low level, and getAnnotations takes a list of DOM nodes
17:10:11 <tilgovi> ... you can use existing DOM APIs to enumerate the nodes in a paragraph and then pass that
17:10:39 <tilgovi> nickstenn: If anyone wants to know what's going on under the hood, I can walk them through the code
17:11:05 <paoloC> q?
17:11:10 <paoloC> q+
17:11:26 <MiguelAraCo> MiguelAraCo has joined #annotation
17:11:47 <tilgovi> nickstenn: It's worth stressing this is a low-level API it is not meant to be pretty
17:11:56 <tilgovi> ... there are lots of edge cases you need to address if you're writing an application that uses this
17:12:05 <tilgovi> ... but the advantage is you can serve all scenarios, even if it is more work
17:12:15 <tilgovi> q-
17:12:26 <tilgovi> nickstenn: This is not intended to help with storage, persistence, or retrieval.
17:12:37 <tilgovi> ... it is not intended to help with fuzzy anchoring, or taking a serialized annotation and finding a bit of the document.
17:12:45 <tilgovi> ... and it is not necessarily intended to help with serialization
17:13:03 <tilgovi> ... that is one of the more interesting questions, I think, trying to understanding how the serialization would work
17:13:12 <tilgovi> ... is there a way we could do it completely orthogonally to this piece
17:13:21 <tilgovi> ... This is merely a reflection of the "annotation state"
17:13:37 <tilgovi> nickstenn: Open questions for the group
17:13:52 <tilgovi> ... does this "smell" right? should it be imitating other APIs with, for instance, createAnnotation API
17:13:59 <fjh> q+ tb
17:14:03 <tilgovi> ... Events vs Mutation Observers?
17:14:52 <tilgovi> ... This deals with "reified state", references to bits of a live DOM thing... is this the right thing for it to be doing?
17:14:56 <tilgovi> ... How does serialization work?
17:14:58 <bigbluehat> q+
17:15:29 <tilgovi> ... Lastly, this is not a bulk API. Does it need a bulk component? How would we find that out? What performance testing would we need to do to find out?
17:15:52 <azaroth> q?
17:16:07 <fjh> ack shepazu
17:16:22 <tilgovi> shepazu: First, thank you for putting this together.
17:16:33 <fjh> orthogonality is good
17:16:34 <tilgovi> ... I think it's orthogonal to something other things like the RangeFinder, I like how you went low-level
17:16:43 <tilgovi> ... another reason to do that is because you can compose it up into other things
17:16:47 <fjh> modularity, testability etc are useful
17:16:49 <tilgovi> ... that's very much the trend the right now
17:17:15 <tilgovi> ... things like the CSS Houdini project is trying to give CSS more explicit, lower-level components, so I think your instinct is right
17:17:19 <tilgovi> ... I think it does smell okay
17:18:38 <tilgovi> shepazu: in your model, is the event only sent when someone does something via script? or does it also change when the underlying DOM changes?
17:18:48 <tilgovi> ... If I have a target and that target goes away... that's when you start getting into mutation
17:19:26 <tilgovi> ... This thing is a meta-thing on top of the document, so it doesn't change the document itself, so you wouldn't get into loops
17:19:38 <tilgovi> ... but for utility sake, if the target of an annotation changes I might want an event, but then it might get us into mutation observers
17:19:43 <fjh> q?
17:20:00 <tilgovi> nickstenn: I don't have a whole answer, but at the moment the events are triggered by user (script) actions on the annotation only
17:20:43 <tilgovi> ... for the benefit of people who have not run into this before, let's say you do have a long document and things are popping into and out of existence as you scroll, that's a real example of where you might attach an annotation to a document nad then the piece of document where that is attached just disappears
17:20:56 <tilgovi> ... that at the moment does not cause any problems, because the annotations are attached to the dom elements
17:21:08 <tilgovi> ... and if the elements are released the annotations go away
17:21:27 <tilgovi> ... If you have a reference to the node, you can get the annotations, otherwise you can't use the API to get to the annotations
17:21:33 <azaroth> q+ to ask about multiple targets and destroyed nodes
17:21:50 <tilgovi> shepazu: what if I create a node, create an annotation, and then attach the paragraph to the annotation as a target, and then insert that into the document
17:22:02 <tilgovi> ... does the node have to be in the document
17:23:17 <tilgovi> fjh: A big thank you for all this work, it helps move stuff forward.
17:23:25 <tilgovi> ... my instinct is you're doing the right thing
17:23:38 <tilgovi> ... you want to keep it simple and we can do separate specs to build on it
17:23:46 <tilgovi> ... we want it to be testable, modular, usable, so I think it's the right approach
17:24:06 <tilgovi> ... I would suggest when we have a draft spec we can run it by the TAG and get feedback, so I think we can ask the right people and get feedback in no time
17:24:21 <fjh> ack fjh
17:24:21 <Zakim> fjh, you wanted to ask about server integration
17:24:25 <tilgovi> ... Just because we do one thing that's simple doesn't mean we can't do other things on top
17:24:32 <fjh> ack TimCole
17:24:45 <tilgovi> TimCole: Right now you have the annotation, addTarget and addBody, right now those are the only two methods
17:24:53 <tilgovi> ... the fact that the target can encompass multiple nodes is interesting
17:24:56 <fjh> q+
17:25:12 <tilgovi> ... the next question is, what's the functionality for multiple targets or for removing a node within a target, are any of those things there yet or are they priorities?
17:25:18 <tilgovi> nickstenn: A couple questions in there
17:25:21 <fjh> I recommend we start simple
17:25:32 <tilgovi> ... other properties, absolutely. If we're going to have an Annotation class it needs to actually support the pieces of the model
17:25:50 <tilgovi> ... multiple targets, this does multiple targets
17:26:02 <tilgovi> ... you can do addTarget multiple times
17:26:20 <tilgovi> ... If I remember correctly, addTarget gives back the Target object and then you can remove that object
17:26:47 <tilgovi> ... and what happens if the piece targeted changes, I don't think that matters until serialization time
17:27:03 <fjh> ack paoloC
17:27:05 <tilgovi> ... and that is why DOM Annotations doesn't, in the general operation, need to worry about that
17:27:16 <tilgovi> paoloC: I have a few points. My first impression was "this is really neat".
17:27:34 <tilgovi> ... my second reaction is that I'm worried about the complexity of the model and that possible the body and the target are open ended
17:27:45 <tilgovi> ... I'm sure we can extend to accomodate this
17:28:00 <tilgovi> ... how do you feel about complex highlighting, overlapping, nested, all these complications
17:28:04 <tilgovi> ... is that all still orthogonal?
17:28:10 <tilgovi> nickstenn: I think that is a completely separate issue
17:28:23 <tilgovi> ... DOM Annotations lets you attach as many annotations as you like to the same piece of the document
17:28:43 <tilgovi> paoloC: But if you have not nested annotations you have to break them down in the document
17:29:00 <tilgovi> nickstenn: I think you have to be careful not to consider it the same as creating highlights in the document
17:29:07 <tilgovi> ... this is a separate problem
17:29:20 <tilgovi> paoloC: then I was worried about the dynamicity of the documents.
17:29:39 <tilgovi> ... I agree that the part that could be hard is the storage
17:29:57 <fjh> q?
17:30:00 <tilgovi> nickstenn: My personal mental model of how we're going to do this stuff is that we may have to think about storage as being a bit more of an op log approach than a CRUD approach
17:30:24 <tilgovi> ... someone is creating annotations in a changing document, the storage component might simply be watching that and then by some heuristic might decide at some point that we're at a place where we can save that off to a remote server
17:30:57 <tilgovi> ... if you like, you create the annotation once and that's the right annotation and then it's the responsibility of the persistence component to know that the annotation might need to be updated when the annotation does change
17:31:45 <tilgovi> paoloC: I'm worried about actions and the difference between document pieces loading and document pieces getting deleted
17:32:20 <azaroth> azaroth has joined #annotation
17:32:20 <tilgovi> ... I think if we had to use this in a framework I would have to duplicate some functions in the code
17:32:46 <tilgovi> ... talking in paricular about ReactJS
17:33:09 <csillag1> q+
17:33:13 <fjh> ack tb
17:33:31 <tilgovi> tbdinesh: The way I see an annotation happen is that there are first selectable objects
17:33:34 <tilgovi> ... if you can't select you don't have targets
17:33:40 <tilgovi> ... could be text but there are lots of other things
17:33:50 <tilgovi> ... so what is it that makes something annotateable?
17:33:55 <tilgovi> ... is how we select something
17:34:03 <tilgovi> ... I'm not sure this is the smallest
17:34:13 <tilgovi> nickstenn: I think you're right, if you can't select a piece of a document you can't annotate it
17:34:29 <tilgovi> ... to address the issue directly, I think that's true, but there is an extent to which that is not the problem of this component
17:34:34 <tilgovi> q+
17:34:44 <tilgovi> ... how does the user interface work? not the problem of this component.
17:35:03 <tilgovi> ... what this component needs is a Target object, which is some domain object that provides a reference, if you like, to the thing you have selected
17:35:08 <tilgovi> ... possibly also a way of serializing that
17:35:19 <tilgovi> ... and what this deals with is Targets that are themselves Nodes in an HTML document
17:35:44 <tilgovi> tbdinesh: would it be simpler if you didn't do selection across the DOM elements
17:36:07 <tilgovi> nickstenn: so you're saying that the ability to create a target that spans multiple elemenst in the document means this isn't the simplest thing
17:36:12 <tilgovi> ... I think that's interesting
17:36:13 <fjh> how does fit with create body first then add targets model?
17:36:26 <tilgovi> ... my gut tells me when a user annotates an HTML document they're not thinking about elements and the DOM tree
17:36:32 <tilgovi> ... they're thinking about a "logical document"
17:36:45 <tilgovi> ... if I'm using MS Frontpage it might span 500 elements for no apparent reason
17:36:58 <tilgovi> ... that's why a target can refer to a range, which can span multiple nodes
17:37:11 <tilgovi> shepazu: Target is not yet defined, as far as I can tell. It might be a Range or it might be a section of a 3D document.
17:37:32 <tilgovi> ... I can't pass an event on the 15th second of a video, but we can target that
17:38:15 <tilgovi> tbdinesh: I think we need to think a little bit lower
17:38:18 <tilgovi> nickstenn: I think we're all saying the same thing
17:38:18 <fjh> q?
17:38:34 <fjh> ack bigbluehat
17:38:56 <tilgovi> tbdinesh: this is to do with elements that are not part of the document
17:39:19 <tilgovi> ... one thing we do is to make annotations that are navigable for a page that is not accessible
17:39:26 <tilgovi> ... (talking about accessibility)
17:39:37 <tilgovi> ... You change the page through your annotation, and that is the page your annotations work on
17:40:02 <tilgovi> nickstenn: I think what you're describing is annotations of things that don't exist exactly in the document
17:40:12 <tilgovi> q-
17:40:31 <tilgovi> tbdinesh: To clarify, there's a DOM Element and it's not identified as part of the navigation
17:41:03 <tilgovi> bigbluehat: I think there are more pieces that aren't presented here, and this is the DOM surface area, which comes and goes with the DOM state machine
17:41:08 <tilgovi> ... there's got to be other pieces
17:41:19 <tilgovi> ... there's a growing contigent that want to get rid of the DOM state machine, and want a different sort of expression
17:41:25 <tilgovi> ... but for the thing that we have, I think this works well
17:41:47 <tilgovi> nickstenn: the thing to do is for us to identify the use case we're describing, make sure that the use case is recorded, so we can ask "is the thing that we've built going to cover the use case"
17:41:56 <tilgovi> fjh: "Are we clear on what the goal is"
17:57:38 <azaroth> azaroth has joined #annotation
17:58:54 <fjh> fjh has joined #annotation
17:59:08 <TimCole> scribenick: TimCole
17:59:32 <fjh> q?
17:59:42 <paoloC> q+
17:59:48 <paoloC> q-
17:59:52 <paoloC> q?
18:00:26 <TimCole> nickstenn: from an extensibility perspective you may wish to annotate parts that are not in the document
18:00:27 <MiguelAraCo> MiguelAraCo has joined #annotation
18:00:30 <fjh> Much thanks to Randall for excellent scribing
18:00:31 <RayD> RayD has joined #annotation
18:00:34 <fjh> q?
18:01:03 <RayD> present+ Ray_Denenberg
18:01:18 <fjh> rrsagent, generate minutes
18:01:18 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
18:01:22 <TimCole> shepazu: let's i have an image in my document, but no alt tag. now i want to attach a description for accessibility
18:01:25 <RayD> (lost connection, rejoining)
18:01:35 <fjh> q?
18:01:53 <TimCole> ... this is an annotation. you would create an annotation attach to image and add a body which is the description
18:02:22 <nickstenn> s/extensibility/accessibility/
18:02:25 <TimCole> tb: I annotate to change the dom in order to support accessibility
18:03:08 <TimCole> bigbluehat: use case coverages -- paolo and i do use cases, mostly protocol to date. need help on client-side use cases
18:03:34 <TimCole> ... what doesn't DOMAnnotations handle, i.e., non DOM State Machine annotations
18:03:42 <nickstenn> the use case to capture from above was "Annotate elements that aren't in the document in order to indicate that they *should* be. As a blind person, I want to let the page author know that a <nav> element should be present in the document, so that I can navigate with a screenreader."
18:04:01 <TimCole> ... what about all the annotations I got from the DOM, and now I want to do client-side persistence.
18:04:18 <TimCole> ... what are the additional pieces we need to address?
18:04:23 <fjh> ack azaroth
18:04:23 <Zakim> azaroth, you wanted to ask about multiple targets and destroyed nodes
18:04:32 <shepazu> q+
18:04:33 <fjh> q+ tb
18:05:02 <TimCole> azaroth: when the node is destroyed, would the annotation be destroyed?
18:05:26 <bigbluehat> q+
18:05:56 <TimCole> ... want to have multiple targets, one which is in view, the other goes out of view, what happens to the annotation
18:06:11 <TimCole> nickstenn: the annotation doesn't go away until the target count go to zero
18:07:12 <TimCole> azaroth: in the process of adding targets, the problem is that if your first target goes off screen before you get to the second target.  There is no longer an annotation to which you can attach target2
18:07:15 <tilgovi> q+
18:07:18 <tilgovi> q-
18:07:47 <fjh> discusson of whether annotation is lost when attached to DOM if page scrolled byeond the point of that annotation
18:07:56 <fjh> q?
18:07:59 <fjh> ack fjh
18:08:17 <TimCole> shepazu: the annotation is temporarily stored in the DOM, but the annotation application could maintain the annotation even when the part of the DOM to which it is attached has gone out of scope
18:08:51 <fjh> q+
18:09:01 <TimCole> ... but my annotation application could still be stored in the application and the application than reattaches it to the DOM when the node comes back in scope
18:09:10 <fjh> ack csillag
18:09:36 <TimCole> csillag1: trying to imagine going from current model to DOM Annotation
18:10:13 <TimCole> ... current system handles some of these use cases because it operates at a level above the DOM
18:10:43 <azaroth> Situation to check back in on:  An annotation that is being created should have two or more targets.  The annotation is created, the first target is created and added. Then the page is scrolled such that the first target is out of the viewport and the element gets destroyed before the second target is added. [+]
18:11:15 <TimCole> ... so the client application could talk both to the DOM Application and to another module, the anchoringManager
18:12:08 <TimCole> nickstenn: one example is annotation of PDF using js.  When you do this not all of the pages of PDF are available at the same time
18:12:09 <azaroth> Two things to determine:  Is the annotation object's existence maintained by the JS application's reference to it, even if the DOM node is destroyed? And (2) are there sufficient events that the annotation's first target can be persisted or re-created when the element is recreated by scrolling back to it.
18:12:34 <TimCole> ... I would argue that annotating all occurrences of spatula in a PDF is out of scope for the Client API
18:12:40 <fjh> q?
18:13:07 <TimCole> ... you could still do this using pdf.js in conjunction with an annotation ClientAPI
18:13:22 <tilgovi> q+
18:13:56 <TimCole> shepazu: need to understand what is done by the Client Application and what is done by the Annotation Client API
18:14:38 <TimCole> nickstenn: if you are building an annotation application, you will have to keep track of nodes that come in and out of the DOM, not expect the ClientAPI to do this
18:15:01 <TimCole> fjh: how do we talk about this?
18:15:40 <fjh> need to capture that work may be required to match low level API and DOM model to user use cases, need to clarify use cases
18:15:51 <TimCole> shepazu: in order to accomplish the goals of the user, we need to break it into its constituent mechanical parts
18:15:55 <fjh> example - user wants to annotate all instances of a word in document, yet only portion of document displayed
18:16:00 <TimCole> ... there will be lots of moving parts
18:16:20 <TimCole> nickstenn: DOMAnnotation is a library to be used by an Application
18:16:27 <fjh> q?
18:16:37 <TimCole> fjh: the Application builder has to deal with this.
18:17:30 <TimCole> tb: accessibility use cases- does it make sense to have blank node targets?
18:17:45 <fjh> s/this/matching the user use cases to the capabilities of the underlying library and DOM implementation/
18:17:49 <TimCole> ... say I want encryption for my annotations
18:18:02 <tilgovi> q+
18:18:06 <TimCole> ... what is inside the annotation is only relizable after decryption.
18:18:24 <fjh> encryption is another example of application logic vs underlying library
18:18:53 <TimCole> nickstenn: another example - it should be the user right to annotate documents over which they have no control, and they may want to do so in a way that may not be visible to document owner
18:18:56 <tilgovi> I think this a great example of where privacy issues that fjh alluded to become real
18:19:11 <TimCole> ... so there are some serious security issues and use cases
18:19:51 <TimCole> ... for example, I am a human rights lawyer investigating abuses and looking at a document on a company website
18:20:17 <TimCole> ... I do not want people to run javascript on their page that sees my annotations on that document
18:20:47 <TimCole> ... another example, i can run code on a page to determine whether links are purple or blue (visited / unvisited)
18:20:54 <TimCole> ... that is a privacy violation.
18:21:21 <bigbluehat> q?
18:21:21 <TimCole> ... how do we a DOM scope in which a user can create annotations not visible to javascript already on that page
18:21:40 <fjh> issue - DOM scope for user to create annotations that are not visible to hosting server page
18:21:52 <TimCole> shepazu: conversely how do allow page javascript to see annotations that i've attached to the DOM
18:22:21 <TimCole> nickstenn: invite someone from WebAppSec
18:22:48 <takeshi> takeshi has joined #annotation
18:22:56 <TimCole> shepazu: so this is important that one option should allow annotations to be created without modifying the DOM
18:23:14 <TimCole> tb: in other cases you do want to be able to modify the DOM
18:24:10 <TimCole> shepazu: so, should be able to modify the DOM or not according to the needs of the users
18:24:45 <TimCole> tb: another use case - re-narration.
18:25:05 <TimCole> ... this allows users to see alternative narrations that they can understand better
18:25:12 <TimCole> ... different renditions of a page
18:25:17 <fjh> also suggest we invite privacy interest group as well
18:25:32 <TimCole> ... we tend to get shutdown notices because it looks like phishing
18:26:48 <TimCole> nickstenn: the issue is that we're using annotations to re-write pages for some users
18:28:42 <TimCole> bigbluehat: there are other, possibly more appropriate  technologies that could do this (XSLT)
18:29:13 <TimCole> tb: took us through an example page
18:29:34 <TimCole> ... so here's a page in English
18:29:55 <TimCole> ... here's a way to get to this page rewritten in a different language
18:30:35 <TimCole> ... so can this happen at the client (to avoid server being blocked)
18:31:05 <TimCole> nickstenn: this is essentially a translation use case
18:31:27 <TimCole> ... I don't think this poses any issues for us
18:31:46 <TimCole> ... so on the client I can mutate the page once I load it
18:32:05 <TimCole> ... so as a user I can apply an extension to do this same thing
18:32:26 <TimCole> ... so yes, an annotation applications should be able to do this.
18:32:51 <fjh> q?
18:33:23 <TimCole> tb: another use case is cascading annotations
18:33:45 <TimCole> ... so a user can see th first layer of annotations
18:33:53 <fjh> server side only annotation system might not work, in that annotations could replace text and then page treated as phishing attack (?)
18:33:58 <TimCole> ... and then can see a second generation of annotations
18:34:15 <TimCole> ... this is about how annotations of the same target are dealt with
18:34:40 <TimCole> bigbluehat: like an RSS feed for annotation
18:35:19 <azaroth> azaroth has joined #annotation
18:35:27 <TimCole> nickstenn: this is an interesting model of how annotations are related to other annotations, but this is higher level than the annotation ClientAPI
18:35:43 <TimCole> ... there doesn't seem to be a problem here, but we need to check it to make sure
18:36:45 <azaroth> q+ to ask if annotations can be referred to in Annotation#addTarget()
18:36:51 <TimCole> bigbluehat: as a reader i want to aggregate annotations of a target, and then I may want to see only the net result of applying all of these annotations
18:36:51 <tilgovi> q-
18:37:39 <TimCole> bigbluehat:  please add use cases to the wiki
18:38:09 <azaroth> q?
18:38:12 <TimCole> bigbluehat: we need specifics, e.g., annotations as transformations
18:38:18 <bigbluehat> https://www.w3.org/annotation/wiki/Use_Cases
18:41:46 <fjh> ack tb
18:41:50 <fjh> ack shepazu
18:42:57 <TimCole> shepazu: comments on DOMAnnotation - re the question about how does Nick's proposal work with mutations of targets?
18:43:33 <TimCole> ... my intuition is that in order for an application to detect that a target has mutated, perhaps we should use the mutation observation rather than something annotation specific
18:44:03 <TimCole> ... so when a mutation observer event is raised, the annotation client can check if the target has changed
18:44:48 <TimCole> nickstenn: should annotation change events fire whenever an annotation may have changed? Right now they don't. If a word inthe middle of the target happens, no annotation change event fires.
18:45:05 <TimCole> ... not a design decision but an implementation choice
18:45:30 <fjh> we need to document the use cases in enough detail before detailing solutions; however understanding the solution space in advance can also be helpful
18:46:00 <fjh> q?
18:46:01 <TimCole> ... I suspect that the answer to your question is either annotation application builder wants to know when serialization of annotation has changed, alternatively you could set your own mutation observer monitoring
18:46:14 <TimCole> ... we should try to answer this by looking at specific use cases
18:46:18 <fjh> nickstenn: developer use cases should be focus
18:46:40 <TimCole> shepazu: when something doesn't have to be annotation specific we should favor that approach.
18:46:50 <fjh> principles - doug - when not necessary to have annotation specific solution try to use general solution
18:47:08 <fjh> q?
18:47:37 <TimCole> ... is there a generalizable use case for specific set of events you describe, i.e., more generalizable than just annotations? If we can make it generalizeable
18:47:40 <TimCole> ... we should.
18:48:25 <TimCole> ... if we have a footnote mechanism where the footnote is in the dom, can we characterize it as an annotation.
18:48:54 <TimCole> ... so when a footnote is created or comes into scope, can we use the annotation Client API to handle footnotes
18:49:05 <azaroth> +1 to Doug's question
18:49:32 <fjh> is question to convert existing footnote into annotation later?
18:49:34 <TimCole> paoloC: or you considering adding microdata to the dom as a kind of change that would trigger an event of interest to annotation api
18:49:58 <TimCole> azaroth: should embedded annotations of things in the page trigger the annotation API?
18:50:36 <TimCole> fjh: are you suggesting that a document containing footnotes would then be treated as annotations when loaded?
18:51:17 <TimCole> shepazu: yes, you could load a wikipedia article with references (notes) and so we could treat these as annotations
18:51:34 <TimCole> ... don't know if this a good idea, but we should talk about it
18:52:21 <azaroth> q?
18:52:27 <TimCole> nickstenn: related Rob's question, if you have annotations (clearly labeled) as such embedded in a document, should annotation events fire?
18:52:42 <fjh> issue - how can annotations embedded  in doc be handled by client API, also can heuristics be used to recognize footnotes
18:52:46 <fjh> ack bigbluehat
18:53:38 <TimCole> bigbluehat: Aaron and I are the only ones other than Nick who has used DOMAnnotation. There are additional pieces of a complete annotation client api - we need to decide what those other pieces are
18:54:07 <fjh> bigbluehat: define boundaries, what is provided by browser vs what application needs to do
18:54:23 <TimCole> ... we need to decide where these other pieces live, e.g., in the browser, on the server, between servers, etc.  client side api is probably not sufficient.
18:54:50 <TimCole> ... so DOMAnnotations doesn't address plain-text annotations, image annotations, etc.
18:55:07 <fjh> ack fjh
18:55:15 <TimCole> ... so in a similar fashion that we have named things in the data model, we know need to clarify our nomenclature.
18:55:20 <paoloC> q?
18:55:40 <TimCole> fjh: we can benefit from going back to Web IDL, etc.
18:56:34 <TimCole> bigbluehat: so in using DOMAnnotations I had to go to back to XPath and so on to find the target in order to give it  to DOMAnnotations
18:57:15 <TimCole> fjh: so I have to execute the protocol and then handle all sorts of additional steps before I hand it off to DOM Annotations
18:57:39 <TimCole> bigbluehat: which ones are ours to worry about and which are elsewhere
18:58:17 <TimCole> nickstenn: we can formalize DOMAnnotations, but concurrently we can also define the other pieces
18:58:31 <TimCole> bigbluehat: need to map out what's left
18:58:50 <azaroth> q?
18:59:12 <TimCole> ... DOMAnnotation is one piece of an annotationAPI
18:59:41 <fjh> ack azaroth
18:59:42 <Zakim> azaroth, you wanted to ask if annotations can be referred to in Annotation#addTarget()
19:00:39 <TimCole> azaroth: DOMAnnotations, an annotation is created, can that annotation then be used as a target for a later annotation?
19:00:55 <TimCole> nickstenn: how do we decide what target types are in scope?
19:01:29 <TimCole> nickstenn: more speicifically what target types are in scope for DOMAnnotations
19:02:35 <TimCole> shepazu: is the annotation created by DOMAnnotations addressable as a DOM node? and should DOMAnnotation be able to have targets outside the DOM?
19:03:06 <tilgovi> q+
19:03:27 <TimCole> nickstenn: DOMAnnotations does not support the full annotation model, and we should not try to support through this API targets outside a rendered document
19:03:29 <fjh> need to clarify scope of each work item, e.g. DomAnnotations on specific rendered document
19:04:15 <TimCole> azaroth: so for a reply to an annotation you might need a separate API that works at a higher level to allow access to the annotations outside the DOM
19:04:55 <TimCole> nickstenn: using DOMAnnotator to annotate annotations opens the door to annotate almost anything outside the DOM
19:05:23 <TimCole> tilgovi: DOMAnnotations is meant to address a subset of the data model supported use cases
19:05:30 <fjh> q?
19:05:33 <fjh> ack TimCole
19:05:36 <fjh> ack tilgovi
19:07:14 <bigbluehat> q+
19:07:15 <fjh> open question of degree of annotation functionality is to be supported by DomAnnotation and need to document
19:07:18 <fjh> q+
19:07:21 <TimCole> shepazu: what about the use case of annotating a node that has been created but not added to the DOM (yet)? It would be useful to allow creation of annotation that may have to do with something not attached to the document but related should be okay
19:07:54 <fjh> need clariy on required model and limit to features
19:08:03 <TimCole> nickstenn: my implementation says that a target is a first class object that refers to nodes in the DOM that I can query.
19:08:24 <TimCole> ... as implemented targets are things that have list of DOM nodes
19:08:31 <fjh> q?
19:08:52 <TimCole> shepazu: we may need to define an annotation object as having more flexible.
19:09:06 <fjh> ack bigbluehat
19:09:06 <fjh> q?
19:09:32 <TimCole> bigbluehat: let's take DOMAnnotations and attach to use cases, see what use cases are not covered, and then deal with those.
19:10:43 <TimCole> fjh: actions. Nick will write up DOMAnnotations up to an informal spec
19:11:24 <TimCole> RESOLUTION: Proceed with DOMAnnotations based on Nick's initial work
19:11:38 <fjh> action: nick to prepare initial draft of DomAnnotation
19:11:39 <trackbot> Created ACTION-10 - Prepare initial draft of domannotation [on Nick Stenning - due 2015-04-29].
19:12:03 <fjh> action: bigbluehat documentating use cases
19:12:03 <trackbot> Created ACTION-11 - Documentating use cases [on Benjamin Young - due 2015-04-29].
19:12:50 <fjh> action: azaroth to add creating buckets for client side annotation support to next agenda
19:12:50 <trackbot> Created ACTION-12 - Add creating buckets for client side annotation support to next agenda [on Robert Sanderson - due 2015-04-29].
19:14:48 <MiguelAraCo> My name is Miguel Aragón, and I'm a member of the LDP Working Group
19:15:00 <RayD> RayD has joined #annotation
19:15:23 <azaroth> azaroth has joined #annotation
19:15:44 <shepazu> I'm Doug Schepers, W3C, one of the staff contacts for this WG
19:15:51 <bigbluehat> I'm Benjamin Young, Developer Advocate for Hypothes.is.
19:15:55 <TimCole> Topic: Minutes Approval
19:15:57 <fjh> http://www.w3.org/2015/04/15-annotation-minutes.html
19:16:07 <JakeHart> My name is Jake Hartnell, and I'm a designer / front-end engineer at Hypothes.is.
19:16:35 <TimCole> RESOLUTION: Minutes from 15 April approved.
19:17:53 <TimCole> Topic: Rest of agenda
19:18:34 <TimCole> fjh: should discuss what it will take to release protocol as FPWD
19:18:43 <TimCole> ... need to talk about search, including SRU
19:18:53 <TimCole> ... talk about Robust Anchoring
19:19:13 <TimCole> shepazu: would like to do something similar to what Nick did in explaining where we are
19:20:20 <TimCole> fjh: protocol, footnote, anchoring, search
19:21:06 <TimCole> Break. Restart at 1:15 pm
20:05:02 <azaroth> azaroth has joined #annotation
20:05:07 <tantek> tantek has joined #annotation
20:15:39 <renoirb> renoirb has joined #annotation
20:17:46 <tbdinesh> tbdinesh has joined #annotation
20:18:24 <azaroth> azaroth has joined #annotation
20:19:29 <KevinMarks> KevinMarks has joined #annotation
20:20:17 <azaroth> q?
20:21:17 <fjh> fjh has joined #annotation
20:21:31 <tbdinesh> azaroth: we have a very draft version of the protocol. do we want to discuss and go through how it works now?
20:21:54 <azaroth> http://w3c.github.io/web-annotation/protocol/wd/
20:21:56 <fjh> q+
20:21:56 <fjh> q?
20:22:01 <bigbluehat> q+
20:22:04 <tbdinesh> fjh: in the end there was a query section that need to be removed
20:22:11 <paoloC> paoloC has joined #annotation
20:22:32 <MiguelAraCo> MiguelAraCo has joined #annotation
20:22:33 <tbdinesh> ... my comments would be to get rid of ??
20:22:35 <TimCole> TimCole has joined #annotation
20:22:43 <RayD> RayD has joined #annotation
20:22:58 <tbdinesh> ... get rid of blah blah and activity streams
20:23:12 <tbdinesh> ... target of assertions is the server
20:23:51 <tbdinesh> ... do we prob with not be REST?
20:24:01 <azaroth> ack bigbluehat
20:24:04 <paoloC> q+
20:24:06 <azaroth> ack fjh
20:24:18 <tbdinesh> bigbluehat: rob, perhaps you could do an elevator pitch
20:24:35 <azaroth> http://w3c.github.io/web-annotation/protocol/wd/
20:24:36 <tbdinesh> .. what does it not do and a bit about what it does
20:24:56 <fjh> remove notifications and query section, remove mention of acttivity streams, remove 'blah blah blah' text, add clarification of test assertion targets (server)
20:24:57 <tbdinesh> azaroth: the purpose of the protocol is to allow clients to communicate with the server
20:25:04 <fjh> Q?
20:25:16 <tbdinesh> ... to create to delete.. assumes RISC as the core principle
20:25:31 <tilgovi> s/RISC/REST/
20:25:36 <tbdinesh> s/RISC/REST
20:25:40 <TimCole> q+
20:25:49 <fjh> s/do we prob with not be REST//
20:26:02 <tbdinesh> ... in order to avoid such questions LDP platform exists
20:26:17 <fjh> rrsagent, generate minutes
20:26:17 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:26:21 <tbdinesh> ... 1st section about containers. containers taken from teh LDP spec
20:26:45 <tbdinesh> ... LDP does not use REST for such as how do you find containers that exist
20:27:08 <tbdinesh> ... full tech reco on undating a PATCH
20:27:13 <fjh> Meeting: Web Annotation F2F
20:27:19 <fjh> rrsagent, generate minutes
20:27:19 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:27:32 <tbdinesh> ... you can update it with PUT - but to change you do a PATCH
20:27:54 <fjh> s/Rest of Agenda/Client APIs/
20:27:56 <tbdinesh> ... LD PATCH but there aer other PATCH such as json PATCH
20:27:58 <fjh> rrsagent, generate minutes
20:27:58 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:28:24 <tbdinesh> ... SLUG my_annotation CAN rather than SHOULD
20:28:35 <fjh> s/Topic: Rest of agenda/Topic: Client APIs/
20:28:40 <fjh> rrsagent, generate minutes
20:28:40 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:28:51 <azaroth> q?
20:28:57 <bigbluehat> q+
20:29:02 <azaroth> ack paoloC
20:29:14 <tbdinesh> paoloC: i am currently using a RESTful approach
20:29:21 <RayD> q+
20:29:26 <fjh> i/.*very draft version.*/Topic: Protocols
20:29:31 <fjh> rrsagent, generate minutes
20:29:31 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:29:47 <tbdinesh> ... in my case i use an approach to insert new annotations - is that done with a PATCH
20:30:14 <tbdinesh> ... i need to understand annotation vs a container
20:30:31 <tbdinesh> azaroth: i see container as an end point where annotations are mainted
20:30:45 <tbdinesh> ... you cannot use PATCH to update all of the annotations in a container
20:31:04 <tbdinesh> paoloC: if you want to replace all items
20:31:12 <tbdinesh> azaroth: you need to do one by one
20:31:49 <tbdinesh> paoloC: to update an annotation with in a set, it goes into an it. that would not be possible?
20:31:54 <tbdinesh> azaroth: thats correct
20:32:14 <azaroth> q?
20:32:16 <azaroth> ack TimCole
20:32:20 <tbdinesh> ... we need to talk about what are the operations to perfomr such things
20:32:51 <tbdinesh> TimCole: 3.1.1.1 is there a size cap to page
20:32:56 <tbdinesh> azaroth: lets do it away
20:33:39 <tbdinesh> ... i think the question is if the LDP grp publishes pagin as note? we shd formatively define it
20:34:09 <tbdinesh> dauwhe: there is no impl
20:34:26 <shepazu> q+
20:34:27 <tbdinesh> azaroth: as Ray was saying we might pull of paging
20:35:15 <tbdinesh> TimCole: i have an annotaion server. i might have data for annotations
20:35:28 <tbdinesh> ... is there any virtual?
20:35:59 <tbdinesh> azaroth: say you have uri example.org/ will create /1 /2 what ever
20:36:21 <paoloC> q+
20:36:43 <tbdinesh> TimCole: we dont have an impl today. can we do this without modifing..
20:37:07 <tbdinesh> ... am just wondering if we go to FPWD right away
20:37:32 <tbdinesh> ... it not really that forbidding but it looks a bit
20:37:59 <tbdinesh> fjh: publishing as often as possible - i was suggesting
20:38:18 <fjh> q?
20:38:37 <fjh> q+ rayd
20:38:38 <tbdinesh> paoloC: i feel unconmfortable going ahead with knowing - if you dont what does that mean for us - do we want to go with it
20:38:50 <azaroth> q?
20:38:52 <fjh> q?
20:38:55 <azaroth> ack bigbluehat
20:39:17 <tbdinesh> bigbluehat: there are a few LDP impls. Apache has 5 i think
20:39:45 <tbdinesh> ... if you have LDP server xy or z these are the tweaks that we make..
20:40:08 <tbdinesh> ... in many cases there will be 1000s of anno in a collection
20:40:19 <tbdinesh> ... we are thinking of 1 per user
20:40:22 <paoloC> q?
20:40:33 <tbdinesh> .. i think we need a discovery mechanism
20:40:37 <tbdinesh> q+
20:41:07 <tbdinesh> bigbluehat: my atom feed say my edit location is ..
20:41:29 <tbdinesh> ... we should prefer json PATCH over LD but both should be possible
20:42:03 <tbdinesh> ... we also need to define some sematics around containers - how do they come into being go out of being..
20:42:31 <tbdinesh> azaroth: agree. if we can find one that is 95% available we make that ..
20:42:44 <tbdinesh> ... js side to impl client side is trivial
20:43:09 <tbdinesh> bigbluehat: i can propose some rephrasing
20:43:15 <fjh> q+
20:43:35 <tbdinesh> azaroth: json PATCH yes. we shd look at various PATCH formats
20:43:47 <paoloC> q?
20:44:03 <tbdinesh> ... defining new containers.. LDP has a way to do that
20:44:23 <tbdinesh> ... there is a prefered header as an interaction model (so can choose)
20:44:46 <tbdinesh> Mitar: annotation could have children annotations like css cascading
20:45:02 <fjh> s/Topic: Client APIs/Topic: Agenda review and update/
20:45:20 <azaroth> q?
20:45:25 <tbdinesh> ... annotation can have membership triples.. with related containers?
20:45:28 <fjh> s/Break. Restart at 1:15 pm/Topic: Protocols/
20:45:32 <fjh> rrsagent, generate minutes
20:45:32 <RRSAgent> I have made the request to generate http://www.w3.org/2015/04/22-annotation-minutes.html fjh
20:45:54 <azaroth> ack RayD
20:45:56 <tbdinesh> azaroth: these are the reasons we shd keep LDP as one of the things
20:46:25 <tbdinesh> bret: server is going to support the protocol if atleast..
20:47:02 <tbdinesh> ... my view you can profile it as an annotation container. if so they dont have to go discover (??)
20:47:21 <tbdinesh> ... with respect to discovery there is mech for discovering resources
20:47:50 <tbdinesh> bigbluehat: in a more is disttributed.. like with blogers.. they need to discover they were there
20:48:41 <tbdinesh> ... from the bolg post you need to discover if its part ofthe bigger collection.then  here is how atom feed is editable.. adom mostly ripped off of rel
20:48:55 <tbdinesh> ... hopefully there is feed format
20:49:21 <tbdinesh> ... but those shd not assume that they are within ok-url??
20:49:31 <azaroth> ack shepazu
20:49:41 <tbdinesh> dauwhe: abt search
20:50:05 <tbdinesh> ... you guys are aware ofthe new hpc? search
20:50:15 <dauwhe> s/dauwhe/???/
20:50:43 <fjh> s/dauwhe:/shepazu:/
20:51:04 <tbdinesh> bigbluehat: briefly currently in the protocol .. right now you come to protoco;l doc and say ah i want to use sparql.
20:51:14 <tbdinesh> ... if that was separate i an pick and choose
20:51:22 <azaroth> ack paoloC
20:51:41 <tbdinesh> paoloC: have a lot to say. hv been anno sets since very very very long time
20:52:02 <tbdinesh> .. they have a lot to say. you can org anno in whatever criteria you want
20:52:07 <tbdinesh> ... like playlists
20:52:21 <Rayd_> Rayd_ has joined #annotation
20:52:32 <tbdinesh> ... the reality it cannot be a single concept. can be very powerful
20:52:43 <tbdinesh> ... i heard sparql i heard graphs
20:53:16 <tbdinesh> ... ?? same annotation can belong to mult containers and can have mult uris
20:53:43 <tbdinesh> ... the way it gets impl in sparql is diverse and even assumption on that can be complicated
20:54:09 <tbdinesh> ... annotation can belong to mult containers and it may not be my annotations.. so what does change mean?
20:54:21 <bigbluehat> q+
20:54:36 <tbdinesh> Mitar: containers contain relationships as a member
20:55:02 <tbdinesh> .. you can go all the way and say i dont want..  blh blh
20:55:12 <tbdinesh> paoloC: is this in the protocol
20:55:18 <tbdinesh> azaroth: its not and i will..
20:55:45 <tbdinesh> TimCole: you dont want to rewrite it
20:55:57 <tbdinesh> azaroth: 4 sent so we have something readable
20:56:45 <tbdinesh> azaroth: ... you can direct, indirect, playlist like , .. it would be diff interaction than creating an annotation
20:56:55 <azaroth> q?
20:56:55 <tbdinesh> paoloC: i dont want to reparse teh entore set
20:56:57 <fjh> q?
20:56:58 <tbdinesh> entire
20:57:10 <azaroth> ack tbdinesh
20:57:18 <azaroth> ScribeNick: azaroth
20:57:29 <azaroth> tbdinesh: How do you discover a container dynamically?
20:57:36 <fjh> tbdinesh: how to discovery containers when encrypted
20:58:05 <tbdinesh> azaroth: 3.1.3? discover of anno containers
20:58:41 <tbdinesh> ... there are a few way you can link to . if the owner of an image wants to a spec container you can link it and follow that link
20:58:54 <tbdinesh> ... caontainers can point to other containers
20:59:31 <fjh> ScribeNick: tbdinesh
20:59:34 <tbdinesh> ... if you have entire server with 1000s of containers you can link to known other containers for you
20:59:53 <tbdinesh> azaroth: we can easily get rid of the rec?
20:59:53 <fjh> q?
21:00:07 <tbdinesh> ... potential options such as well known uris
21:00:47 <tbdinesh> ... [ ] redirects to .. bejamin do you want to speak up against it
21:01:26 <tbdinesh> bigbluehat: there was this piece that was proposed to avoild discover. it was dotwell-known instead of dot well known
21:01:38 <tbdinesh> ... making it hard to discover
21:02:06 <tbdinesh> ... i would be -1 on using it. discovery from anno is an optional thing
21:02:07 <fjh> q?
21:02:36 <tbdinesh> bret: uri in the annotation did not seem to be optional
21:02:48 <tbdinesh> azaroth: in json-ld terms
21:03:04 <tbdinesh> ... that is one of the areas i made some additonal req on top of LDP
21:03:08 <azaroth> ack fjh
21:03:23 <tbdinesh> fjh: so i thought i set my own person anno server
21:03:26 <TimCole> q+
21:03:47 <tbdinesh> ... seems logical to me that i want to retrive annotations for a specific domain
21:05:08 <tbdinesh> ... is this an annotation set - i am confused. my usecase is about easily retrive and manage anno on a given domain
21:05:28 <tbdinesh> ... shd the protocol allow me to deal with specific domain
21:05:44 <shepazu> q+
21:06:32 <tbdinesh> azaroth: will get rid of any notion that hinted that there is only one container
21:07:04 <tbdinesh> TimCole: some people want to do it by name of person smoe by tags some by url
21:07:30 <tbdinesh> bigbluehat: that is why uri are imp there is no way we will fig it out - all cases
21:07:36 <Rayd_> q+
21:08:21 <tbdinesh> paoloC: when ilook for annotations i query give me all anno that target that
21:09:03 <tbdinesh> azaroth: it does provide a use case for how to provide mult containers
21:09:37 <tbdinesh> dauwhe: whole idea of uri being opaque bothers me
21:09:54 <tbdinesh> azaroth: client shd not read meaning into the stricture of the uri
21:09:57 <dauwhe> s/dauwhe/???/
21:10:02 <bigbluehat> Web Axiom https://hypothes.is/a/5DScCXXnTNeJ0uBWpu1cyg
21:10:16 <azaroth> ack bigbluehat
21:10:18 <dauwhe> dauwhe has left #annotation
21:10:27 <fjh> q?
21:10:30 <azaroth> s/???/shepazu
21:11:13 <tbdinesh> ;ast two ??? ares dwhly to shepazu
21:12:51 <tbdinesh> bigbluehat: james snells ldp based impl - he is doing the same for activity streams - we dont want to require the context not rdf.. then we assume one. do ldp container impl let you write plain old json objects
21:13:08 <tbdinesh> Mitar: you can actually do whatever you want to write
21:13:38 <tbdinesh> ... atleast carbon ldp impl impls.. you cannot replace cannot mess with them
21:13:55 <tbdinesh> bigbluehat: shall we rob do similar change
21:14:14 <tbdinesh> ... container types: we might want to be clear about which ones we rec ppl use
21:14:28 <tbdinesh> azaroth: at the moment we only have basic ones
21:14:49 <azaroth> q?
21:14:52 <azaroth> ack TimCole
21:15:16 <tbdinesh> TimCole: i wonder if discover sec we can all something else
21:15:41 <fjh> s/ sec we can all/section should be called/
21:15:52 <fjh> s/section/ section/
21:16:03 <azaroth> ack shepazu
21:16:08 <tbdinesh> fjh: yeah be specific enough
21:16:22 <fjh> s/yeah/yes/
21:16:35 <fjh> s/enough/about the item, such as Container Discovery/
21:17:55 <tbdinesh> shepazu: i am assuming one of these containers.. like the tags. my use case is aggergators. i want to find the top comments from 15 diff anno services having to do with ... i am like trolling .. looking for (i am not proposing ratings) maybe for this site 5 is a good and the other 15 reshares. how would i be able to solve that using your protocol_
21:18:15 <tbdinesh> azaroth: to me its an anno state?
21:18:31 <paoloC> q+
21:18:32 <fjh> s/anno state/annotation set/
21:18:37 <fjh> q+
21:18:42 <tbdinesh> shepazu: i am not talking abt that part. what could an aggregator do to selectively..
21:19:10 <tbdinesh> azaroth: i think it leaves in the search part and server interaction protocol
21:19:18 <tbdinesh> fjh: what action
21:19:34 <tbdinesh> azaroth: when we talk about search we keep this use case in mind
21:20:10 <tbdinesh> shepazu: we could make a note specifically greared towards aggregators.
21:20:13 <azaroth> q?
21:20:15 <azaroth> ack Rayd_
21:20:30 <fjh> need to get aggregators to create set
21:20:54 <tbdinesh> Rayd_: i post an annotation and it will be on your servers right
21:21:03 <tbdinesh> azaroth: yes if it is a container
21:21:27 <tbdinesh> Rayd_: i can anno anything i want but no one else can get that
21:21:39 <tbdinesh> Rayd_: whats the purpose
21:21:49 <tbdinesh> fjh: for me to create anno and not share
21:22:32 <tbdinesh> azaroth: i could have an image in my stanford domain say rob.jpg
21:23:22 <tbdinesh> ... client would know this person wants me to post it there. normally i want to post it some where. there is no hard linking.
21:23:47 <tbdinesh> TimCole: the resource of the anno may not know what the anno.
21:24:07 <tbdinesh> fjh: there is no gaunrantee that the taget will remain
21:24:48 <tbdinesh> azaroth: i will rewrite to: any reco uri and can exisit on any server anywhere
21:24:52 <azaroth> q?
21:24:54 <shepazu> q+
21:25:30 <tbdinesh> Rayd_: i think there shd be sec in the doc showing various scenarios
21:25:45 <tbdinesh> azaroth: an example at the begging would be good
21:26:12 <tbdinesh> shepazu: i look at an aggregator as it would store anno and dupl from else where
21:26:35 <tbdinesh> ... search engine is not holding holding the annotations.
21:27:02 <azaroth> q?
21:27:03 <azaroth> ack paoloC
21:27:06 <tbdinesh> bigbluehat: could be the protocol. could be feed format. could be more than 1 anno and it looks like this
21:27:34 <tbdinesh> paoloC: related to ebooks but in gereneral there shd be criteria that shd tell me if it can be published in a diff context
21:28:12 <tbdinesh> paoloC: index but does not stoer is prob okay
21:28:29 <fjh> s/stoer/store/
21:28:32 <tbdinesh> shepazu: lots of torrent search engines tell what the context is but do not store
21:28:33 <azaroth> q?
21:28:50 <tbdinesh> ... thats why uri is very plyable.. it goes away after a while
21:29:10 <tbdinesh> fjh: 2.5 hrs until 5 and we have 3 topics
21:30:57 <tbdinesh> fjh: from process point of view it shd be published but we are not ready at all today
21:31:06 <fjh> action: azaroth to update Protocol draft based on F2F discussion comments
21:31:07 <trackbot> Created ACTION-13 - Update protocol draft based on f2f discussion comments [on Robert Sanderson - due 2015-04-29].
21:31:47 <fjh> action: shepazu to add aggregation use case to wiki
21:31:47 <trackbot> Created ACTION-14 - Add aggregation use case to wiki [on Doug Schepers - due 2015-04-29].
21:32:45 <fjh> Do we have counter-proposals to the Protocol
21:32:59 <fjh> Do we have volunteers to work on implementations to vett the Protocol draft
21:33:32 <fjh> Tim Cole has group working on this, bigbluehat plans to work with James Snell's draft to work on protocol as well
21:33:33 <tbdinesh> bigbluehat: my plan is to use james snel's code to impl protocol
21:34:28 <tbdinesh> fjh: if its not comprehensible enough we are not ready
21:35:45 <bigbluehat> scribe: bigbluehat
21:35:50 <fjh> Topic: Publishing
21:35:56 <fjh> ScribeNick: bigbluehat
21:36:35 <bigbluehat> TimCole: ...publishers want to be able to include footnotes in digital publications
21:36:42 <bigbluehat> ...had conversations with HTML5 about "footnote"
21:36:48 <bigbluehat> ...no reason to use the model
21:36:59 <shepazu> thread on footnotes: https://lists.w3.org/Archives/Public/public-digipub-ig/2015Feb/0090.html and blog post on requirements:  http://davidmacd.com/blog/html51-footnotes.html
21:37:00 <fjh> q?
21:37:01 <bigbluehat> ...do we (annotation WG) have any concerns about this as a use case?
21:37:02 <fjh> q+
21:37:11 <azaroth> ack fjh
21:37:12 <azaroth> ack shepazu
21:37:27 <bigbluehat> fjh: had a conversation with social web
21:37:30 <MiguelAraCo_> MiguelAraCo_ has joined #annotation
21:37:38 <bigbluehat> ..."everything's an annotation"
21:37:45 <bigbluehat> ...he's sort of right
21:37:51 <bigbluehat> ...but does it need to be?
21:38:02 <JakeHart> q+
21:38:12 <bigbluehat> TimCole: the concern I would add is that if we make a tag for footnote, people would use it for all kinds of things
21:38:20 <bigbluehat> fjh: will they?
21:38:27 <bigbluehat> TimCole: we told them to hold off until we talked about it
21:38:45 <bigbluehat> ...they end up having to solve some of the same problems (if they use the tag)
21:38:51 <bigbluehat> ...where do they put it? what goes into it?
21:39:04 <bigbluehat> fjh: that's not the author's problem, it's the implementors
21:39:32 <bigbluehat> TimCole: go ahead and use it then, and we can turn it into something richer?
21:39:54 <bigbluehat> azaroth: our primary use case is third party annotations
21:40:07 <bigbluehat> ...party 3 talking about party 1's things.
21:40:16 <paoloC> q+
21:40:19 <bigbluehat> ...if party 1's talking about party 1's things, if they want to use annotations, great!
21:40:34 <bigbluehat> shepazu: but what if I'm annotating something I made, but don't have control over
21:40:38 <bigbluehat> azaroth: then you're not the publisher
21:40:39 <fjh> q?
21:40:44 <fjh> q+
21:41:08 <bigbluehat> shepazu: concerned by the "anything can be an annotation" argument
21:41:13 <bigbluehat> ...I want to shut that down
21:41:19 <bigbluehat> ...so it's clear what we're focused on
21:41:38 <bigbluehat> ...I'm concerned that people think that we think that anything is an annotation
21:41:48 <bigbluehat> ...it doesn't have to be, so I want to keep the scope focused
21:41:52 <bigbluehat> ...two things:
21:42:01 <bigbluehat> ... - the digital publication working group
21:42:14 <bigbluehat> ... "annotations are too heavy; we need something lightweight"
21:42:21 <bigbluehat> ... (context is accessibility)
21:42:38 <bigbluehat> ... I explained more, and think it didn't end up being an issue
21:42:54 <bigbluehat> ... I linked earlier to the email thread and blog post that included more footnote use cases
21:43:15 <bigbluehat> ... let's say I have a document and navigate to and from the footnote
21:43:26 <bigbluehat> ... how do I know what to go back to if the footnote is used multiple times
21:43:53 <bigbluehat> fjh: you could use a bib?
21:43:59 <bigbluehat> shepazu: that's not very webby. people don't want to
21:43:59 <fjh> make three footnotes, use ibid
21:44:06 <bigbluehat> s/bib/ibid/
21:44:19 <bigbluehat> shepazu: CSS is also looking at footnotes and end notes
21:44:24 <bigbluehat> ...where do we put these, how do we render them
21:44:39 <bigbluehat> ...I'd like us to consider a <note> element
21:44:50 <bigbluehat> ...it would contain all the things to serialize to the data model
21:44:53 <bigbluehat> ...but in markup
21:44:54 <azaroth> q?
21:44:55 <fjh> q?
21:44:58 <azaroth> ack JakeHart
21:45:14 <bigbluehat> JakeHart: this is something I feel strongly about
21:45:23 <bigbluehat> ...footnotes are actually talking about something external
21:45:36 <bigbluehat> ...and in annotation, something like an easy to use <note> element would help
21:45:46 <bigbluehat> ...I come from publishing, and people there write markup
21:45:53 <bigbluehat> ...if it maps back to something more powerful, all the better!
21:46:04 <bigbluehat> ...they're often talking about external things
21:46:08 <bigbluehat> ...it's important to map citations
21:46:10 <bigbluehat> ...references
21:46:16 <bigbluehat> ...in a more intelligent way
21:46:24 <bigbluehat> ...so a footnote, note, element would be very helpful
21:46:36 <bigbluehat> ...perhaps even comments about things that happen in the scholarly paper, etc
21:46:47 <bigbluehat> ...I'd love something like a footnote, note element
21:46:57 <azaroth> q?
21:47:00 <azaroth> ack paoloC
21:47:07 <bigbluehat> ...coming from the publishing world, are scared (rightly or wrongly) of the complexities
21:47:18 <bigbluehat> paoloC: in Domeo, we've parsed all the footnotes and notes and stored annotations
21:47:33 <bigbluehat> ...the reason why we did all this work, we wanted to build networks of citations, etc, all in the same way
21:47:47 <bigbluehat> ...while doing that I realized "sure, all these things can be annotations"
21:47:54 <bigbluehat> ...but I only did it when I really needed it
21:48:04 <bigbluehat> ...and not push people to use annotations for everything
21:48:14 <azaroth> q+
21:48:27 <bigbluehat> ...some of these footnote issues are bad UI
21:48:34 <MiguelAraCo> MiguelAraCo has joined #annotation
21:48:35 <bigbluehat> ...you don't need to scroll to the bottom of the page and come back
21:48:37 <bigbluehat> ...it's not paper
21:48:50 <bigbluehat> ...someone who publishes the resource
21:49:10 <bigbluehat> ...can look at my annotations and knowing I'm the author can make my annotations part of the content
21:49:22 <bigbluehat> ...if we get annotation into the publishing process, we'd be entering a forest
21:49:30 <bigbluehat> ...where it's already overused / abused
21:49:39 <azaroth> ack fjh
21:49:40 <bigbluehat> ...if it's already well defined, we shouldn't try to replace it
21:49:58 <bigbluehat> fjh: I think you were saying a footnote would be markup, and not technially an annotation
21:50:00 <TimCole> q+
21:50:11 <bigbluehat> paoloC: correct, but you should be able to parse it, change it, re-express it
21:50:29 <bigbluehat> fjh: the reasons for markup seem to be that it's legible, easier, something people already do
21:50:38 <bigbluehat> ...people don't just say "here's some markup" but "here's the model"
21:50:55 <bigbluehat> ...if we got into that part of it, we could help define these tags in a way that's compatible with our data model
21:51:03 <bigbluehat> TimCole: it is HTML5
21:51:08 <azaroth> q?
21:51:09 <bigbluehat> shepazu: the HTML WG rather
21:51:18 <bigbluehat> ...HTML WG is probably going to be a smaller group
21:51:37 <bigbluehat> ...HTML Interest Group (IG) is a task force, larger group to route the other pieces of HTML
21:52:02 <bigbluehat> fjh: so it's not going to be fixed in HTML5...HTML-whatever
21:52:07 <TimCole> q-
21:52:12 <bigbluehat> ...not sure who to talk to
21:52:16 <bigbluehat> shepazu: I'm not sure either
21:52:22 <bigbluehat> TimCole: they've not come back with more info
21:52:32 <azaroth> ack azaroth
21:52:51 <bigbluehat> ...this came up in digital publishing 'cause this is where it happens
21:52:55 <shepazu> q+
21:53:05 <fjh> Q+
21:53:07 <bigbluehat> ...my sense, though, is that communication has died off about it between those gorups
21:53:23 <bigbluehat> azaroth: think we're in consensus that there should be a way to map markup to the model
21:53:41 <bigbluehat> ...so that everyone doesn't have to figure out how it was done, write string parsers, etc,
21:54:01 <takeshi> q+
21:54:03 <bigbluehat> ...so to what extent do we have to be a part of it to point to how we'd like it done
21:54:12 <shepazu> http://www.w3.org/community/openannotation/wiki/RDFa
21:54:15 <fjh> proposed RESOLUTION: support for markup to support footnotes but consider noting relation to annotations
21:54:19 <bigbluehat> shepazu: so, I started this some time ago
21:54:22 <bigbluehat> ...before the WG started
21:54:43 <bigbluehat> ...it's not defined whether we go to them or they come to us
21:54:54 <bigbluehat> ...I think we'll be asked, but we could also go to them and say
21:55:04 <bigbluehat> ..."does this thing meet your needs"
21:55:21 <bigbluehat> ...I found my RDFa attempts very frustraiting
21:55:29 <bigbluehat> ...I think we should have a friendlier way
21:55:38 <bigbluehat> ...I consulted with experts
21:55:40 <tbdinesh> q+
21:55:41 <bigbluehat> ...and still got it wrong
21:55:56 <azaroth> ack shepazu
21:55:58 <azaroth> q?
21:56:03 <bigbluehat> fjh: I thought we'd go the other way where the markup came from the markup related groups, and then we map it to the data model
21:56:08 <azaroth> ack fjh
21:56:12 <bigbluehat> shepazu: we're saying the same thing. as long as it maps, we're OK
21:56:19 <bigbluehat> fjh: I put a proposed resolution in the chat
21:56:28 <bigbluehat> ...we should record some sort of decision
21:56:35 <paoloC> Examples of RFDa markup http://www.w3.org/community/openannotation/wiki/RDFa
21:56:35 <azaroth> ack takeshi
21:56:38 <bigbluehat> ...it sounds like we have consensus around markup
21:56:40 <azaroth> q?
21:56:45 <bigbluehat> azaroth: let's clear the queue before we decide
21:56:57 <bigbluehat> takeshi: in Japan there's a special annotation
21:57:01 <bigbluehat> ...Ruby Annotation
21:57:14 <bigbluehat> ...to provide the pronunciation guide for Kanji
21:57:19 <bigbluehat> ...on the Kanji
21:57:20 <fjh> http://www.w3.org/TR/ruby/
21:57:38 <JakeHart> FYI: Kanji are Chinese Characters.
21:57:42 <bigbluehat> ..it helps younger readers to express the Kanji
21:58:12 <bigbluehat> shepazu: does everyone understand the Kanji problem?
21:58:22 <bigbluehat> ...Kanji is not pronounceable direclty
21:58:27 <bigbluehat> ...the other kana's are
21:58:42 <bigbluehat> ...and Ruby allows you to attach kana to Kanji to show how to pronounce it
21:58:48 <bigbluehat> s/show/explain
21:59:03 <bigbluehat> azaroth: is focusing on this going to help us know how to provide other annotations?
21:59:36 <bigbluehat> takeshi: specifically, the Ruby Annotation has appeared on specific, unknown words
21:59:49 <bigbluehat> ...in the case that we need the representation, the ruby tag should be used
22:00:02 <bigbluehat> fjh: I'm loosing how this connects to the discussion
22:00:21 <bigbluehat> shepazu: some people feel we should consider changing to annotations for these
22:00:35 <bigbluehat> fjh: it's confirming the same thing we're thinking with footnote for mapping markup to the model
22:00:45 <bigbluehat> azaroth: it shows how we might do it in markup
22:00:57 <bigbluehat> shepazu: we might talk to Mike Smith and ???
22:01:09 <bigbluehat> ...they understand Ruby really well
22:01:10 <azaroth> ack tbdinesh
22:01:25 <azaroth> bigbluehat: fantasai
22:01:36 <bigbluehat> s/???/Fantasai
22:01:46 <bigbluehat> tbdinesh: the HTML group will only consider markup
22:01:59 <bigbluehat> ...something is a <nav> for instance
22:02:10 <bigbluehat> ...so let's say you have some deal with an annotation
22:02:17 <bigbluehat> ...where it goes from a note, to a footnote, to ruby
22:02:30 <bigbluehat> ...we called it annotation before, but now it becomes a tag
22:02:40 <azaroth> q?
22:02:57 <bigbluehat> fjh: we are different than the other groups because we're thinking of annotation first, and then other serializations
22:03:11 <bigbluehat> azaroth: I think we should look at the proposal and then break
22:03:39 <fjh> proposed RESOLUTION: rough consensus to support using markup for footnotes but with review to make sure details enable mapping to annotation
22:03:48 <JakeHart> +1
22:03:54 <azaroth> +1
22:03:54 <shepazu> +1
22:03:56 <bigbluehat> +1
22:04:18 <bigbluehat> proposed RESOLUTION: rough consensus to support using markup for footnotes but with review to make sure details enable mapping to annotation
22:04:20 <TimCole> +1
22:05:12 <bigbluehat> shepazu: azaroth are you coming to the hack days? I was going to hack on an HTML proposal
22:05:16 <bigbluehat> azaroth: not sure I'll make it
22:05:45 <fjh> action: TimCole to talk with digital publishing group re consensus (and Rob)
22:05:45 <trackbot> Created ACTION-15 - Talk with digital publishing group re consensus (and rob) [on Timothy Cole - due 2015-04-29].
22:05:50 <bigbluehat> ...I'd like an action on TimCole and myself to talk to the dpub group
22:05:53 <fjh> q?
22:06:04 <bigbluehat> breaking until 3:15 pm
22:23:51 <fjh> fjh has joined #annotation
22:24:01 <JakeHart> scrive
22:24:09 <JakeHart> scribe jakehart
22:24:18 <azaroth> azaroth has joined #annotation
22:24:23 <bigbluehat> scribenick: JakeHart
22:24:25 <csillag1> csillag1 has joined #annotation
22:24:27 <fjh> Topic: Robust Anchoring
22:24:27 <fjh> ScribeNick: JakeHart
22:24:52 <shepazu> https://docs.google.com/presentation/d/1eTsTlPCoIiJzk5q3JIJ6BFneWE9FtXnRHaIgKcLVN4g/edit#slide=id.g99fce293a_0_25
22:25:31 <shepazu> https://docs.google.com/presentation/d/1eTsTlPCoIiJzk5q3JIJ6BFneWE9FtXnRHaIgKcLVN4g/edit?usp=sharing
22:26:13 <fjh> s/Topic: Robuist Anchoring/RangeFinder API/
22:26:26 <fjh> s/Topic: Robust Anchoring/RangeFinder API/
22:26:50 <JakeHart> shepazu: I'm not personally sold on the Rangefinder API being the right thing. This is a strawman.
22:27:19 <JakeHart> What is the lowest-level API we can define to find the location of a portion of a DOM document based on a set of selectors?
22:28:02 <JakeHart> Use Cases:
22:28:13 <JakeHart> Anchoring annotations:
22:28:13 <JakeHart>  locating text (for example) between sessions even when the text (or its context) may have changed
22:28:13 <JakeHart> Finding text:
22:28:14 <JakeHart>   exposing the browser’s native find-in-page
22:28:27 <paoloC> paoloC has joined #annotation
22:28:33 <JakeHart> There are some constraints:
22:29:02 <JakeHart> Performance, Simplicity, Low level, Only works on current document
22:29:17 <JakeHart> Questions:
22:29:19 <JakeHart> Should it iterate over the document, or find all matches in one pass?
22:30:02 <JakeHart> What should the return value contain?
22:30:10 <nickstenn> q+
22:30:17 <JakeHart> What is useful information for this to give back?
22:30:28 <JakeHart> Should we have a separate edit-distance API?
22:31:04 <JakeHart> How closely should we map to the data model?
22:31:46 <JakeHart> Strawman spec: https://specs.webplatform.org/rangefinder/w3c/master/
22:32:00 <JakeHart> Please annotate!
22:32:26 <JakeHart> Orthogonal Goals:
22:32:42 <JakeHart> Defining a URL syntax that lets you link to a document fragment, given a rangefinder API
22:33:04 <JakeHart> shepazu: it would be nice if I give it a simple URL.
22:33:12 <JakeHart> Styling the range once you’ve found it, without modifying the DOM
22:33:30 <JakeHart> i.e. without injecting spans for highlights.
22:33:43 <azaroth> q?
22:33:48 <tbdinesh> tbdinesh has joined #annotation
22:34:12 <fjh> q+
22:34:22 <azaroth> ack nickstenn
22:34:24 <azaroth> ack fjh
22:34:51 <JakeHart> nickstenn: I just thought I would state that in response to the first question, you can take an API that iterates and turn it into something that can find all in one pass.
22:34:56 <azaroth> q+
22:35:06 <JakeHart> fjh: what was your question?
22:35:10 <JakeHart> I missed it.
22:36:02 <fjh> I asked what the rationale was for find-all given
22:36:14 <JakeHart> azaroth: question about separate edit-distance API.
22:36:14 <azaroth> Is the edit distance API option to be combined with the finder api as an argument, or as lots of separate finders?
22:36:23 <fjh> s/the rationale/rationale/
22:36:42 <fjh> s/rationale/rationale given/
22:36:50 <fjh> s/all given/all/
22:37:26 <TimCole> q+
22:37:30 <fjh> q+
22:37:40 <azaroth> ack azaroth
22:37:42 <azaroth> ack TimCole
22:37:51 <tbdinesh> q+
22:38:04 <JakeHart> The URL syntax relates to the discussion about fragment identifiers.
22:39:00 <JakeHart> Are you thinking about an approach where you can pass in range finder arguments in the URL?
22:39:12 <JakeHart> ^^ TimCole
22:39:45 <JakeHart> shepazu: talking about svg fragments.
22:40:24 <JakeHart> mySVG.svg#svgView(0,10,100,10)
22:40:38 <JakeHart> ^^ Example?
22:41:29 <JakeHart> TimCole: You wouldn't try to overload #?
22:41:37 <JakeHart> shepazu:
22:42:28 <bigbluehat> q+
22:42:53 <fjh> shepazu: example  !view(..)  or !text="   "& start=10
22:42:53 <JakeHart> Find a symbol that's not commonly used...
22:43:11 <fjh> q?
22:43:17 <azaroth> q?
22:43:31 <tantek_> tantek_ has joined #annotation
22:43:44 <JakeHart> TimCole: the publishing group would like to be able to get to places in documents.
22:43:47 <azaroth> ack fjh
22:44:06 <JakeHart> "Don't break the web."
22:44:17 <fjh> idea - follow up on function query parameter
22:44:23 <azaroth> q?
22:44:54 <JakeHart> Parameters on the URL scheme are things that should be dealt with the rangefinder API.
22:45:12 <shepazu> https://specs.webplatform.org/rangefinder/w3c/master/
22:45:27 <tantek__> tantek__ has joined #annotation
22:45:53 <azaroth> ack tbdinesh
22:46:07 <JakeHart> tbdinesh: I missed the rational for edit distance.
22:46:45 <fjh> shepazu: the quick brown fox is now the quick brown box, so how to match without edit distance
22:47:02 <JakeHart> shepazu: Documents change, what if a publisher corrects a small error?
22:47:30 <azaroth> ack bigbluehat
22:47:34 <fjh> shepazu: might decide to limit RangeFinder to text
22:47:52 <TimCole> q+
22:48:46 <JakeHart> bigbluehat: scrolling through the URI spec, fragment identifiers are mapped to media types...
22:49:15 <JakeHart> thinks we should explore a URL syntax
22:49:19 <fjh> isn't there a length limit on URLs?
22:49:40 <fjh> s/thinks/... thinks/
22:49:40 <JakeHart> shepazu: the browser could use the rangefinderapi to resolve the URL.
22:49:59 <fjh> q+
22:50:37 <JakeHart> bigbluehat: there are several needs for how to express something additional about a URL in a single line of text.
22:50:45 <JakeHart> Is this something we should define?
22:51:07 <paoloC> q?
22:51:52 <JakeHart> shepazu: it is not specifically in our charter to define a URL syntax.
22:52:35 <JakeHart> TimCole: you can mint a service that takes the three things and turns them into a URL... like a link shortener.
22:53:33 <JakeHart> azaroth: this could work with anything without messing with URL structure.
22:54:15 <paoloC> q+
22:54:23 <fjh> q-
22:54:47 <azaroth> ack TimCole
22:54:55 <JakeHart> azaroth: moving from URL syntax.
22:55:38 <azaroth> ack paoloC
22:56:38 <paoloC> http://www.w3.org/TR/its20/
22:57:11 <fjh> NIF 2.0 http://persistence.uni-leipzig.org/nlp2rdf/ontologies/nif-core/nif-core.html
22:59:42 <JakeHart> In terms of URI selection they have theory on how to select text.
22:59:47 <azaroth> q?
22:59:49 <JakeHart> paoloC: ^^
23:00:05 <JakeHart> paoloC: we should explore that work.
23:00:28 <fjh> s/In terms/paoloC In terms/
23:00:39 <JakeHart> shepazu:
23:00:51 <JakeHart> I would like some feedback on the list.
23:01:33 <JakeHart> If people think that this the right kind of direction... then if they could tell me what kind of return value would be useful.
23:03:01 <JakeHart> fjh we need to figure out what we need to do and how.
23:03:11 <JakeHart> shepazu: please give feedback
23:03:20 <JakeHart> https://specs.webplatform.org/rangefinder/w3c/master/
23:03:45 <fjh> q+
23:03:47 <JakeHart> shepazu: do people think I'm going in the generally right direction?
23:04:20 <JakeHart> tilgovi: I like the idea of exposing the browsers find functionality for programmatic access.
23:04:42 <nickstenn> q+
23:05:02 <tilgovi> I am skeptical of the generalizability of edit distances for fuzzy search
23:05:25 <JakeHart> tilgovi: we might be able to do something simpler.
23:05:39 <JakeHart> Which might allow us to prototype this in user space.
23:06:03 <azaroth> ack fjh
23:06:10 <JakeHart> my major concern is about the range of possible meanings for distances and thresholds.
23:06:32 <JakeHart> fjh: it would be valuable to create a new draft.
23:06:35 <tilgovi> q+
23:06:51 <azaroth> ack nickstenn
23:08:01 <JakeHart> nickstenn: if we don't know how this going to work in practice we should do some experimentation first.
23:08:25 <azaroth> ack tilgovi
23:08:51 <JakeHart> tilgovi: thinks finding ranges is the right direction.
23:09:02 <azaroth> q?
23:10:23 <fjh> paoloC: worked on fifteen distance algorithms, for google ???, only one used inthe end because of performance reasons, ppm
23:10:32 <tilgovi> s/???/refine/
23:10:44 <tilgovi> That bolsters my confidence in the utility of a single algorithm
23:10:44 <paoloC> https://github.com/OpenRefine/OpenRefine/wiki/Clustering-In-Depth
23:10:52 <tilgovi> Even if it's not useful for every single case
23:11:10 <tilgovi> q+
23:11:15 <JakeHart> fjh: the message is performance matters and sometimes flexibility doesn't matter so much.
23:11:33 <JakeHart> paoloC: what mattered is it had to work in the browser.
23:12:16 <JakeHart> shepazu: if ppm was good enough, maybe that is what we should standardize.
23:12:16 <azaroth> ack tilgovi
23:12:26 <paoloC> Original code https://code.google.com/p/simile-vicino/
23:12:35 <JakeHart> tilgovi: two performance related thoughts.
23:13:16 <JakeHart> One way to avoid locking the browser would to be include a timeout in the API.
23:13:58 <azaroth> q?
23:14:00 <fjh> q+
23:14:27 <JakeHart> The other thing about performance, especially if this is about anchoring annotations, it may be that performance improvements for checking for multiple things in one pass. Performance could be huge...
23:15:03 <tilgovi> s/improvents for/could be improved by/
23:15:19 <fjh> Topic: Search
23:16:21 <fjh> q+
23:16:31 <JakeHart> azaroth: the search question comes up as necessary for us to solve to have a useful client server interaction
23:17:02 <JakeHart> ... to avoid having to load 10,000 annotations on the client just to find two relevant annotations.
23:17:31 <JakeHart> ... if we propose something to LDP it could likely be well recieved.
23:17:47 <JakeHart> ... There is lot's of prior art here.
23:18:27 <JakeHart> ... Open search: an atom based search.
23:18:42 <TimCole> http://www.loc.gov/standards/sru/
23:18:52 <fjh> http://zing.z3950.org/cql/intro.html
23:18:55 <JakeHart> ... Solar: well adopted platform, has it's own query peramiters.
23:19:05 <tilgovi> s/peramiters/parameters/
23:20:09 <JakeHart> ... We should come up with use cases and tick them off.
23:20:12 <TimCole> http://www.opensearch.org/
23:20:17 <bigbluehat> q?
23:20:17 <azaroth> q?
23:20:24 <bigbluehat> q+
23:20:35 <JakeHart> ... then let's discuss a rational and defensible approach for a proposal.
23:20:54 <bigbluehat> fjh: link to CQL?
23:21:08 <bigbluehat> s/fjh: link to CQL?//
23:21:09 <TimCole> q+
23:21:21 <JakeHart> fjh: CQL has a lot of nice things in it.
23:21:33 <azaroth> q?
23:21:35 <JakeHart> ... worth looking into more.
23:21:38 <azaroth> ack fjh
23:21:54 <JakeHart> ... not sure how it would fit since it's all text based.
23:22:19 <fjh> CQL text based, offers simple syntax for query, powerful including proximity, yet would need to define index sets
23:23:01 <fjh> rayd: querying, sorting, filtering, result set all requirements to consider
23:24:01 <fjh> ... paging
23:24:01 <azaroth> q?
23:24:14 <JakeHart> ... if you are going to come up with a query spec, you want it to be able to query, page, and return a result set...
23:24:36 <shepazu> q+
23:24:41 <azaroth> ack bigbluehat
23:25:17 <JakeHart> bigbluehat: search method proposal
23:25:30 <azaroth> q+ to suggest CQL as posted query with SEARCH verb
23:27:18 <bigbluehat> http://tools.ietf.org/html/draft-snell-search-method-00
23:27:55 <JakeHart> bigbluehat: Snell's most recent rfc proposal.
23:28:33 <fjh> sounds like this is important but we would still need to define search query details, result set, paging etc?
23:29:23 <JakeHart> bigbluehat: concerned about crafting or selecting a query language for annotation.
23:29:41 <azaroth> ack TimCole
23:30:57 <RayD> RayD has joined #annotation
23:31:00 <bigbluehat> ...there are simple use cases that don't require a "query language"--find me all annotations for a resource could look like sending in just that resource identifier to an endpoint (either in the URL, or wherever)
23:31:28 <azaroth> +1 to TimCole
23:32:01 <azaroth> q?
23:32:06 <azaroth> ack shepazu
23:32:07 <fjh> q+
23:32:13 <paoloC> q?
23:33:22 <bigbluehat> q+
23:33:47 <azaroth> ack azaroth
23:33:47 <Zakim> azaroth, you wanted to suggest CQL as posted query with SEARCH verb
23:34:10 <TimCole> at this point in spec and community development we should limited our self to a very locked-down profile that specifies exactly what kinds of searches are supported, a limited number sort options
23:34:42 <TimCole> and a limited range of what can be returned.
23:34:56 <bigbluehat> RayD: can you drop any and all links you have for these things. :) would be super helpful
23:35:43 <azaroth> q?
23:35:43 <fjh> q+
23:36:18 <JakeHart> TimCole: we've got  to think of things that work well on dated servers.
23:37:29 <azaroth> ack fjh
23:39:04 <azaroth> ack bigbluehat
23:39:29 <fjh> action: rayd to provide summary of sru level 1 for group to enable considering approach
23:39:30 <trackbot> Created ACTION-16 - Provide summary of sru level 1 for group to enable considering approach [on Ray Denenberg - due 2015-04-29].
23:39:47 <azaroth> proposal was to write a straw person document that uses the SEARCH verb to transport a restricted CQL query
23:40:09 <JakeHart> bigbluehat: the primary use case is finding all the annotations for this uri.
23:40:14 <azaroth> and enumerate the potential query patterns as part of that against the known use cases for search
23:40:39 <JakeHart> ... Maybe we can spec a smaller thing that is not search?
23:41:08 <fjh> +1 to bigbluehat of having method to obtain annotaitons for specific resource without requiring search
23:41:17 <JakeHart> ... if i give it the URI it comes back with the feed location.
23:41:43 <azaroth> q+
23:42:27 <JakeHart> ... that could be shipped sooner. You're not doing a search.
23:42:36 <azaroth> ack azaroth
23:42:41 <JakeHart> ... then search could be layered on top of that.
23:43:01 <JakeHart> azaroth: SIU, CQL, OMIPQH
23:43:22 <JakeHart> ... everyones hates OMIPQH.
23:44:11 <JakeHart> ... could feeds actually be linked to?
23:44:32 <azaroth> OAI-PMH
23:45:24 <JakeHart> The concern with lists of feeds is that you need to be able to enumerate the feeds.
23:45:47 <fjh> q?
23:46:05 <JakeHart> TimCole: OAIPMH allows hierarchical sets.
23:47:02 <azaroth> Rob's concern:  Impossible to enumerate the list of possible feeds, and potentially useful combinations of query patterns
23:47:35 <azaroth> For example still need to be able to construct a URL syntax that includes the target of the annotation
23:48:01 <azaroth> Which is then a URL pattern for searching
23:49:20 <JakeHart> fjh: we need to follow up on this.
23:49:34 <JakeHart> fjh: we need to know when our next meeting is.
23:50:04 <JakeHart> fjh: are we going to meet next wednesday.
23:50:28 <JakeHart> fjh: we will meet on April 29th.
23:50:39 <fjh> Topic: Meetings
23:51:27 <JakeHart> takeshi: can we talk about the data model.
23:51:35 <takeshi> https://gist.github.com/tkanai/e2984cfa14cf099baa94
23:51:45 <fjh> will meet next Wed 29 April
23:51:50 <fjh> Topic: Data Model
23:52:51 <fjh> issue - text offset works in some languages but  not others, e.g. Javascript but not Python etc
23:52:54 <JakeHart> takeshi: concern that the offset will work in certain programing  languages but not in others.
23:53:22 <tilgovi> +1
23:53:28 <JakeHart> takeshi: to use the offset we need to make clear definitions.
23:53:57 <JakeHart> takeshi: IMO the python type of counting system is good.
23:55:21 <JakeHart> takeshi: the result of the Javascript offset counter is not acceptable.
23:56:31 <tilgovi> nickstenn: explains that string lengths are not a straightforward thing when multi-byte character encodings that do not used a fixed number of bytes are in use
23:56:40 <JakeHart> fjh: so what's the solution?
23:56:57 <JakeHart> nickstenn: we need to be precise about how offsets are calculated.
23:57:02 <tilgovi> takeshi: requests that we are precise about what we mean for text offsets and that we are careful not to cause too much performance penalty
23:58:01 <JakeHart> nickstenn: IMO the most logical way of counting things is to normalize to count from the full composed form.
23:58:18 <JakeHart> nickstenn: this is expensive though.
23:58:42 <JakeHart> *fully
23:58:44 <shepazu> http://www.w3.org/International/docs/charmod-norm/
23:58:48 <shepazu> q+
23:59:13 <JakeHart> bigbluehat: "Can we just rename it the almost offset?"
23:59:29 <JakeHart> nickstenn: we should have this as an agenda item on another call.
23:59:39 <fjh> action: fjh add offset issue to future agenda item
23:59:39 <trackbot> Created ACTION-17 - Add offset issue to future agenda item [on Frederick Hirsch - due 2015-04-29].
23:59:51 <shepazu> "Character Model for the World Wide Web: String Matching and Searching" http://www.w3.org/International/docs/charmod-norm/