Data has been made reusable and machine-interpretable by publishing it as Linked Data. However, automatically processing Linked Data is not fully achieved yet, as manual e ort is still needed to integrate existing tools and libraries within a certain technology stack. To enable automatic processing, we propose exposing functions and methods as Linked Data, and publishing it in di erent programming languages. Content negotiation can be used to cater to di erent technology stacks, and common, technology-independent identi ers make them discoverable. As such, we can enable automatic processing of Linked Data across formats and technology stacks. By using discovery endpoints, similar to those used to discover vocabularies and ontologies, the publication of these functions can remain decentralized.
By publishing data as Linked Data, we are moving to a Web of integrated, reusable, and machine-interpretable data. However, to process that data, we need processing instructions. E.g., calculating a distance between two points [x1, y1] and [x2, y2] can be done using the Euclidean distance. This, in JavaScript, could be calculated as Math.sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) ).
Libraries and repositories of common functions and methods exist1, but integrating them still requires manual e ort to 'glue' the di erent libraries together. Human intervention is needed, as functions are implemented in di erent technologies, and the way of executing these functions is not declared semantically, thus ruling out machine-interpretability.
At the same time, there are many ongoing e orts to integrate processing
instructions and (Linked Data) applications. For example, integrating
processing functions when mapping from non-RDF data to RDF data [
In this paper, we propose publishing technology-independent function
descriptions as Linked Data. These descriptions provide a common reference for
processing instructions across technology stacks (e.g., JavaScript snippets vs.
Web services). To integrate the processing instructions in di erent technology
stacks, content negotiation can be used to publish the same functions in di erent
implementations [
The proposed methodology consists of the following parts (Figure 1): 1. provide technology-independent semantic descriptions of functions, 2. publish these functions, both their semantic description and the speci c implementations (not necessarily all at the same place), 3. make the semantic descriptions discoverable and queryable, and 4. provide content negotiation to allow uniform access to di erent implementations.
We achieve the rst part of this methodology using for instance the
Function Ontology [
We consider the Function Ontology as it is small and technology/problemdomain independent, and thus allows for easier reuse2. Such a function description serves as a common reference across technology stacks. 2 http://w3id.org/function/spec
Discovering and Using Functions via Content Negotiation
POST /_query (1)
Accept: application/x-javascript _:a fno:solves ex:EuclideanDistanceProblem . (2)Redirect 303 s2.example.com/euclidean.js Web service
JAVA function s1.example.com (0)
JavaScript function (3) function euclidean (points) { […] } s2.example.com
Just as Linked Open Vocabularies [
The proposed methodology uses widespread methods to publish and discover functions, catered to di erent needs. However, they also inherit the same risks as there are in the current Web: just as websites are not always accessible in the language you prefer, functions might not be implemented in the technology needed. Fortunately, similar workarounds can be used: as best-e ort automatic translation systems can provide for translations of websites to your preferred language, there exist engines that use emulation or code translation to allow incorporating code snippets from a di erent programming language4. 3 This compares to a technology-independent https://www.haskell.org/hoogle/ (that helps users discover Haskell functions by type signature), but where the semantics of a function is also taken into account. 4 See, e.g. the Nashorn engine to use JavaScript procedures within the Java Virtual
Machine (https://blogs.oracle.com/nashorn/).
Furthermore, the proposed methodology allows for choosing between remote
web services and locally downloaded methods. Depending on the context
(online/o ine, execution rate and/or data throughput) a user can decide whether
to use the online service, or download the method locally (given that both exist).
The latter would involve (automatically) integrating the downloaded code in the
parent application. Depending on the technology used, the client will need to
interpret the semantic description of a function, to know how to actually
execute a function. For Web services, many declarative description formats exist
to automatically derive this (e.g., Hydra [
Functions can be described semantically and technology-independent using the Function Ontology. By publishing these descriptions alongside their implementations, we provide a uniform access to similar functions for di erent technologies, both accessible remotely and downloadable locally. These implementations can exist distributed, but are made discoverable using centralized endpoints, similar to widely adopted portals such as Linked Open Vocabularies. This in turn allows for machine-interpretable and discoverable libraries of functions.