Danno and Dannotate are tools for creating and displaying annotations for web accessible resources using the Annotea protocol. Danno is an HTTP-based repository that provides APIs for creating, updating, deleting and querying annotations and replies, and for bulk upload and harvesting of annotations. Dannotate is a Web 2.0 application that allows the user to create and view annotations for a web accessible resources.
There are live demonstrator pages for Danno and Dannotate.
Annotea is a protocol for managing web annotations that was developed by a W3C working group in 2000-2002. In the Annotea model, annotations and replies are stored separately from the web resources that they annotate. The resources and their annotations are "brought together" when the user views the resource in a web browser. The Annotea protocol is the protocol that is used by the web browser (for example) to fetch annotations from the repository, create new ones, edit them and delete them. The Annotea protocol is a RESTful protocol that uses HTTP as its underlying transport.
Annotea models annotations and replies as collections of RDF triples. Each annotation or reply is assigned a unique URI by the annotation server when it is created. This URI is used to identify the object in later operations. The base protocol supports the following requests:
Danno implements the complete Annotea protocol with non-standard extensions.
OAI-PMH is a protocol defined by the Open Archives Initiative that facilitates the harvesting of metadata stored in repositories. The OAI-PMH model is that metadata consists of records that can be rendered in a variety of formats. The protocol allows a client to do things such as:
OAI-PMH optionally allows the metadata record-space to be partitioned into (overlapping) named OAI sets, based on repository specific criteria.
Danno includes a server-side implementation of OAI-PMH, allowing remote clients to harvest annotations and replies. Danno implements the mandatory parts of the OAI-PMH protocol and also supports OAI sets as aliases for predefined Danno queries. The Danno demo site also includes a webform based OAI-PMH "client" for trying out Danno's OAI-PMH support.
Note: the Danno implementation of OAI-PMH does not report deleted annotations, and it does not support any of the optional OAI-PMH "containers".
The Annotea protocol defines two base queries; one that queries all annotations for a URL, and another that queries all replies for an annotation. Danno extends the Annotea query language by adding additional base queries, and by adding a number of query restriction parameters. For example:
?w3c_annotates=<some-url>&danno_creator=Steve
This queries all annotations for <some-url> that are recorded as having been created by "Steve". Other Danno-specific parameters modify the way that the result-set is handled and presented.
The Danno demonstration pages include a Query page that is intended to demonstrate the capabilities of the Danno queries.
Danno provides a bulk annotation upload facility as a complement to the normal Annotea approach of creating annotations. The upload facility allows the user to upload collections of annotations in certain formats, and import them into the Danno repository as a "collection". Collections may subsequently be updated and deleted in bulk. This facility is intended to support end users uploading collections of annotations that they have prepared in a different system.
The Danno demonstration pages include an Import page that is intended to demonstrate Danno's upload functionality.
Danno represents annotations and replies internally as RDF triples, and stores them in a back-end triple store. Currently, Danno can be configured to use Sesame, Jena/RDB and Jena/SDB triple stores. Other back-ends could be implemented, provided that the triple store in question is transactional, supports SPARQL and can be accessed from Java.
Dannotate is a Web 2.0 tool that allows users to display, create, edit and delete annotations and replies stored in an Annotea-compliant repository. Dannotate consists of client-side scripts implemented in Javascript and a Dannotate server-side component that provides the bridge between the web browser and a (possibly separate) Annotea repository. (The latter would normally be a Danno instance, but other Annotea server implementations could be used, assuming that they were sufficiently compliant to the Annotea protocol specs.)
Dannotate decorates the web resource (page) in the user's browser window with tags to indicate the presence of annotations. When the user moves the cursor over a tag, the annotation details are shown in a hover window. The user can "pin" the hover window and use it to edit the annotation, create a reply to it or delete it.
New annotations are created by selecting a region of text and using the "Dannotate" bookmarklet to launch the annotation editor window. When the user clicks submit, the annotation is sent to the Danno server, and an annotation tag is added to the page display.
The Dannotate client-side is implemented as non-trusted Javascript so that the end user does not need to install any browser plugins. One consequence of this is that the Dannotate scripts need to be injected into a web page before it can execute. There are two ways that this can happen:
When the user uses the "DannoRepeat" bookmarklet, it sends the current page's URL to the Page Repeater service. This service refetches the web page, parses it, and injects the required <script> elements and so forth, and returns the modified page to the user's browser.
The Danno and Dannotate server-side code base is implemented in Java 6.0, using J2SE and J2EE APIs and a number of third party libraries. JSPs and XSLT are also used. The server-side software currently requires Tomcat 5.5, though porting to other J2EE platforms is feasible. The codebase is designed to be OS platform agnostic. We do of our development and testing on Linux platforms, but Danno / Dannotate have been deployed to Solaris and MacOS with minimal issues.
For details of the third party libraries used, refer to the Maven dependencies reports for Danno and Dannotate.
The Dannotate client-side code is implemented in portable ECMAScript (aka Javascript). The Dannotate client has been tested on the following web browsers:
Internet Explorer 7 and earlier versions are not supported due to issues with browser support for web standards. This is not expected to change.
Danno uses a variety of technologies to facilitate reconfiguration and reuse of components in a range of projects:
For more extensive information on configuration and tailoring, please refer to the Customizing Danno and Dannotate page.