The Document Availability Information API (DAIA) defines a data model with serializations in JSON and XML to encode information about the current availability of documents. This document defines the serialization formats DAIA/JSON and DAIA/XML and a HTTP query API to query DAIA information.

As the amount of data and devices on the Web experiences exponential growth issues on how to integrate such hugely heterogeneous components into a scalable system become increasingly important. REST has proven to be a viable solution for such large-scale information systems. It provides a set of architectural constraints that, when applied as a whole, result in benefits in terms of loose coupling, maintainability, evolvability, and scalability. Unfortunately, some of REST’s constraints such as the ones that demand self-descriptive messages or require the use of hypermedia as the engine of application state are rarely implemented correctly. This results in tightly coupled and thus brittle systems. To solve these and other issues, we present JSON-LD, a community effort to standardize a media type targeted to machine-to-machine communication with inherent hypermedia support and rich semantics. Since JSON-LD is 100% compatible with traditional JSON, developers can continue to use their existing tools and libraries. As we show in the paper, JSON-LD can be used to build truly RESTful services that, at the same time, integrate the exposed data into the Semantic Web. The required additional design costs are significantly outweighed by the achievable benefits in terms of loose coupling, evolvability, scalability, self-descriptiveness, and maintainability.

The concept of the mashup implies the combination of different data sources or functions. Practically, this often means that a mashup makes use of several APIs and tries to produce new insights or new functionalities by mixing them together. The patterns of combination are not random: one can imagine that certain APIs are brought together more often than others. This (short) project proposes to examine this dynamic more closely.

The primary goal of this tutorial to close the gap between the high-level concept of Service-Oriented Architecture (SOA), and the question of how to implement such an architecture once services have been identified. Colloquially, it is often assumed that services in a Web-oriented are implemented as Web services, and these are often exclusively perceived as using the SOAP stack of protocols. Our goal is to describe that Web services can also use other technologies, such as RESTful implementations on top of HTTP. Furthermore, we will explain how a disciplined process can lead from the business level, which is mainly about identifying services on an abstract level, to an IT architecture, and that it is important to not impose architectural constraints (such as defining service in a function-oriented way rather than in a resource-oriented way) too early in the process.

ql.io is a declarative, evented, data-retrieval and aggregation gateway for quickly consuming HTTP APIs. ql.io re-uses concepts and syntax from SQL and JSON to create an imperative style language. Scripts written in this language can make HTTP requests to retrieve data, perform joins between API responses, project responses, or even make requests in a loop.

REST is the architectural style of the Web, and closely related to REST is the concept of a HTTP API. A HTTP API is a programmer-oriented interface to a specific service, and is known by other names such as a RESTful service contract, resource-oriented architecture, or a URI Space.

I say closely related because most HTTP APIs do not comply with the uniform interface constraint in it's strictest sense, which would demand that the interface be "standard" - or in practice: Consistent enough between different services that clients and services can obtain significant network effects. I won't dwell on this!

One thing we know is that these APIs will change, so what can we do at a technical level to deal with these changes as they occur?

This is the REST service of CollateX. To call it, you can post witness data as specified below and get the collation result back in a number of formats.

Microservices developed by a European-funded development collective whose aim it is to promote the interoperability of the tools and methodology we use in the field of digital scholarly editing and research.

Micro services are small cloud deployed web services supporting specific tasks in (any) digital work flow pertaining to larger scholarly tasks. They are the small reusable web published building blocks of digital scholarly tools. They provide the basic solution to interoperability and sustainability for digital scholarly tools Interedition is striving for.

The goal of Simple is to bring the power of simplicity to the world of server side Java. The primary focus of the project is to provide a truly embeddable Java based HTTP engine capable of handling enormous loads. Simple provides a truly asynchronous service model, request completion is driven using an internal, transparent, monitoring system. This allows Simple to vastly outperform most popular Java based servers in a multi-tier environment, as it requires only a very limited number of threads to handle very high quantities of concurrent clients. Simple has consistently out performed both commercial and open source Java Servlet engines and has a fully comprehensive API that is as usable for experienced Java developers as it is for beginners. Best of all, Simple is completely free, and is released under the terms of the Apache License, which ensures its availability for use by open source and proprietary developers alike.

Facepy is a client for Facebook's Graph API that doesn't suck.

Web Intents is a framework for client-side service discovery and inter-application communication. Services register their intention to be able to handle an action on the user's behalf. Applications request to start an Action of a certain verb (share, edit, view, pick etc) and the system will find the appropriate Services for the user to use based on the user's preference.

This is a first pass at implementing a Python wrapper for the Zotero API.

Akara is a platform for developing data services available on the Web, using REST architecture. Akara is open source software written in Python and C.

Akara is specialized for delivering data services, and to a particular set of architectural best practices for doing so. Two of the key points are:

RESTful principles (to maximize the utility, reuseability and integration of resources)
Service composition, and its corollary, divide-and-conquer.
In "the akara way", complex services are combinations of simpler services, which might in turn be combinations of even simpler services, all the way down to the unit transform, which is a simple, independent (i.e. not coupled to other services), highly cohesive conversion from a simple data input to a simple data output.

These combinations of simpler services in Akara are called "Pipelines".

Akara provides a pipeline-based services model, implemented for invocation using REST methods. Services are identified by ID (URI), and are made available at one or more mount points (URLs). Services are abstracted through the REST model so that, for example, if you make a request of an AKara instance, it might be that specific Akara instance that executes the service, or it might be acting as some form of intermediary to other capability, whether in the form of another Akara instance or a completely different technology.

This basic service abstraction system supports complicated service choreography, including round-robin, load-balancing, a race of parallel invocations (e.g. to satisfy emergency processing requests), or even through some sort of scoring system (i.e. I prefer Akara to FooTransformer for XSLT, if available). Improtantly, this flexibility comes without the excess baggage of many "SOA" service models.

Mashups are becoming increasingly popular as end users are able to easily access, manipulate, and compose data from many web sources. We have observed, however, that mashups tend to suffer from deficiencies that propagate as mashups are reused. To address these deficiencies, we would like to bring some of the benefits of software engineering techniques to the end users creating these pro- grams. In this work, we focus on identifying code smells indicative of the deficiencies we observed in web mashups programmed in the popular Yahoo! Pipes environment. Through an empirical study, we explore the impact of those smells on end-user programmers and observe that users generally prefer mashups without smells. We then introduce refactorings targeting those smells, reducing the complexity of the mashup programs, increasing their abstraction, updating broken data sources and dated components, and standard- izing their structures to fit the community development patterns. Our assessment of a large sample of mashups shows that smells are present in 81% of them and that the proposed refactorings can re- duce the number of smelly mashups to 16%, illustrating the poten- tial of refactoring to support the thousands of end users program- ming mashups.

This document defines a vocabulary and processing model for a configurable API layer intended to support the creation of simple RESTful APIs over RDF triple stores.

Wikipedia Miner is a toolkit for navigating and making use of the structure and content of Wikipedia. It aims to make it easy for you to integrate Wikipedia's knowledge into your own applications, by:

providing simplified, object-oriented access to Wikipedia's structure and content.
measuring how terms and concepts in Wikipedia are connected to each other.
detecting and disambiguating Wikipedia topics when they are mentioned in documents.

Accentuate.us uses statistics to predict where special characters are needed on a language-by-language basis.

A reconciliation service is a web service that, given some text which is a name or label for something, and optionally some additional details, returns a ranked list of potential entities matching the criteria.

A collection of the best open data sets and open-source tools for data science, wrapped in an easy-to-use REST/JSON API with command line, Python and Javascript interfaces. Available as a self-contained VM or EC2 AMI that you can deploy yourself.

Loggly helps you collect, index, and store all your log data and then makes it accessible through search for analysis and reporting. All this is done without having to download or install anything on your servers.

Allow your users to collaborate in realtime
Add live status updates and messages
broadcast events to everyone viewing a page

The Text Processing API supports the following functionality:

Stemming & Lemmatization
Sentiment Analysis
Tagging and Chunk Extraction

The new Graph API attempts to drastically simplify the way developers read and write data to Facebook. It presents a simple, consistent view of the Facebook social graph, uniformly representing objects in the graph (e.g., people, photos, events, and fan pages) and the connections between them (e.g., friend relationships, shared content, and photo tags).

The Open Data Protocol (OData) is a Web protocol for querying and updating data that provides a way to unlock your data and free it from silos that exist in applications today. OData does this by applying and building upon Web technologies such as HTTP, Atom Publishing Protocol (AtomPub) and JSON to provide access to information from a variety of applications, services, and stores.

Hurl makes HTTP requests.

These databases integrate information from various projects at the Library and Information Center at Dharma Drum Buddhist College. By providing information on Chinese calendar dates, as well as an onomasticon of person and place names from Buddhist sources they help with disambiguation and geo-spatial referencing of names and dates. The data is openly available through various web-services.

A mini-framework for Django for creating RESTful APIs.

RevCanonical is url shortening with a twist. Instead of creating its own super short versions of links, it checks to see if the link owner has published a shortened version of the given page using HTML link element. If not, we just return the original URL. And you should bug the link owner about providing a better alternative.

Fetching the data using a dynamically generated script tag... the difference in performance was shocking.

The YQL platform provides a single endpoint service that enables developers to query, filter and combine data across Yahoo! and beyond. YQL exposes a SQL-like SELECT syntax that that is both familiar to developers and expressive enough for getting the right data.

Yahoo! GeoPlanet is a resource for managing all geo-permanent named places on Earth. It provides the geographic developer community with the vocabulary and grammar to describe the world's geography in an unequivocal, permanent, and language-neutral manner.

Documents Compass provides non-profit assistance to those who are engaged in or planning documentary editing projects in the electronic age.

The premise behind dynamic bindings is that any search engine, even one that existed prior to development of the standard, need only to provide a dynamic binding - a self-description. It need make no other changes in order to be accessible. A client will be able to access any search engine that provides a description, if only it implements the capability to read and interpret the description and use it to formulate a request (including a query) and interpret the response.

The OASIS Search Web Services Technical Committee is developing search and retrieval web services, integrating various approaches under a unifying model, an Abstract Protocol Definition.

The SeeAlso Linkserver API documentation is intended for web developers that want to write dynamic web pages that include additional links, or to developers that want to provide links and other information to specific resources that people can include in their web pages.

The Google Spreadsheets Data API allows client applications to view and update Spreadsheets content in the form of Google Data API feeds. Your client application can request a list of a user's spreadsheets, edit or delete content in an existing Spreadsheets worksheet, and query the content in an existing Spreadsheets worksheet.

Open GUID consists of the following services to manage web identity: Finding existing unique web identifiers. Establishing new unique web identifiers. Associating legacy identifiers with an open one. Registering identical classes and instances in web ontologies.

JetS3t is a free, open-source Java toolkit and application suite for the Amazon Simple Storage Service (Amazon S3).

Whilst there are many ways to publish metadata, we're going to focus on the use of RDFa, and how to either embed the information in web-pages, or provide a separate XML feed.

We extracted the colours from 3 million “interesting” Flickr images. Using our visual similarity technology you can navigate the collection by colour.

This project provides Web-based services for controlled vocabularies.

AtomServer is a generic data store implemented as a REST-ful web service. It is designed as a GData-style Atom Store.

A summary of the current API, as of June 2008.

Submit an OCLC number to this service, and it returns a list of related OCLC numbers and selected metadata.

POW is a fully-functional open source (GPL) webserver that works inside your browser.

hkit is a simple PHP5 tool for extracting common microformats from a page.

Easily transform your microformatted content to nice, clean, easily digestible, XML, JSON or JSON-P. You can also easily set filters to only receive particular formats.

Your webserver can now serve a standard HTML form that will allow your users to upload their content directly into Amazon S3 on your behalf.

Trestle is a nose plugin that enables you to write testable documentation for web apps.

The Calais web service allows you to automatically annotate your content with rich semantic metadata, including Entities like People and Companies and Events & Facts like Acquisitions and Management Changes.

Using standard HTTP methods, you can fetch a representation of a feature or a collection of features, add new data to the service, or delete data from the service.

The music analyzer API can help power music visualization, music games, artistic installations, and DJ applications with a much deeper level of music structure understanding.

Google's mapping of Atom to JSON.

Flower is a new kind of user programmable web service, especially well suited for applications which process, store, and query XML data sets.

Somehow, code monkeys surrounded by earth-toned cubicle fabric think that it makes them resemble DJs surrounded by crates of vinyl if they use musical buzzwords to refer to the act of combining multiple things into a new one.

CouchDB provides a bulk insert/update feature.

A comprehensive HTTP client library that supports many features left out of other HTTP libraries.

Back up all of your photos, music and documents on your home computer for only $4.95 per month.

A digital edition of the complete contents of the Royal Irish Academy’s Dictionary of the Irish Language based mainly on Old and Middle Irish materials.

Amazon SimpleDB is a web service for running queries on structured data in real time.

The Search web service is a means of opening a database to external enquiry in a standardized manner that facilitates discovery of query and response possibilities and makes it possible for heterogeneous databases to be queried simultaneously with the sam

Using Semantic Web Pipes you can fetch, mix and process RDF files published on the Web.

Docs for Amazon's Elastic Computing Cloud.

The ADL Gazetteer Protocol is a lightweight, stateless, XML- and HTTP-based protocol for accessing gazetteers: dictionaries of geographic placenames.

Mjt makes it very simple to take data from a web service and format it in a browser, with no server support. The templates are hosted and delivered as static HTML, and they are compiled and applied entirely in Javascript.

The project is going to scope the requirements of UK institutional and subject repositories for a service that will reliably and uniquely identify names of individuals and institutions.

A tool to index machine tags and provide a search interface so that you can link up disparate data sources.

An application written for a single node can, using Terracotta, be transparently deployed on an EC2 cluster.

Libferris includes initial support for mounting Web photo services as a filesystem. This means that sites such as flickr.com can be seen as filesystems, which allows users to upload digital pictures easily by using the cp tool with a destination of flickr

SWS is a web service built on top of a subset of ClearForest’s natural language processing toolkit.

This is how you can allow the AS3 Socket and XMLSocket to connect to a low port number, for example to a web server's port 80.

Solr is an open source enterprise search server based on the Lucene Java search library, with XML/HTTP and JSON APIs, hit highlighting, faceted search, caching, replication, and a web admin interface.

What are you doing? Blogging about Twitter.

As my host Michael Buckland observed, there is clarity in the counsel of our fundamentals: making information available, ensuring open access, assisting others in discovery, creating user-empowering tools and services.

Our bet is that most of these companies will realize that they can become even more efficient if they rely upon a few, highly competitive and deeply technical infrastructure suppliers. Engineering for scale matters.

The dominant way in which most people will “program” the web is by writing metadata, not code, and we’ll need an interface as friendly and powerful as Pipes to help them do that.

The client can modify any part of the structure without concern for the origin server for that element, and the server can difference the PUT-back representation to discover changes, validate permissions, and commit permitted changes.