This document serves for faster iterations and discussions of our terminology, as the WoT Architecture document has a stricter merging policy and the GitHub wiki is not writeable for non-editors.
An Interaction Pattern to invoke procedure on a Thing, potentially a long running physical process (e.g., lowering of window blinds).
A running or periodically running process that consumes one or more Things (read and processes there data, control their state) and/or exposes on or more Things (provide access to locally gathered data or computed from consumed Things, provide remote control and management interfaces). The application can be implemented using the Scripting API or native platform APIs. The application may also be distributed over multiple Things and other hosts.
A re-usable collection of blueprints for the communication with different IoT platforms. The blueprints includes the required vocabulary for the Thing Description to map Interactions to platform-specific messages as well as implementation notes for the required protocol stacks or dedicated communication drivers.
Programming interface that allows scripts to access remote Things over the network, local Things in a different execution environment, or directly attached hardware (which is abstracted as Things).
To read in a Thing Description and create a Consumed Thing software object for the application in the local runtime environment.
A software object instance created through the WoT object of the Scripting API that represents a remote Thing used by the local application. It is defined by the ConsumedThing interface of the WoT Scripting API.
Programming interface that allows scripts to discover other Things (local, nearby, or remote).
Linked Data vocabulary that can be used in the WoT Thing Description, but is not defined by W3C WoT.
An Interaction Pattern to subscribe to data pushed by a WoT Server. These can be stand-alone events such as an alarm, change-of-value notifications, or time series of data.
A sandbox within the Runtime that isolates scripts running on the same Servient.
To create an Exposed Thing software object in the local runtime environment that enables the application to provide local state and calls as Interactions over the network.
A software object instance created through the Server API that is implemented locally and can be accessed over the network by remote WoT Clients. It is defined by the ExposedThing interface of the WoT Scripting API.
A functionality exposed by Thing that is defined by the TD Interaction Model.
A formal model that syntactically and semantically maps different network-facing interfaces (i.e., WoT Interfaces) to application-facing interfaces (e.g., the Scripting API -- note that these can also be proprietary APIs when not implementing the WoT Runtime). The Thing Description is built around this model and connects it to Link Data vocabularies.
A default solution to describe common Interactions: Property, Action, and Event.
A specific IoT ecosystem such as OCF, oneM2M, or Mozilla Project Things with its own specifications for application-facing APIs, data model, and protocols or protocol configurations.
A discovery method that can discover Things directly connected to a Servient (e.g., sensor or actuator that is abstracted as Thing).
A discovery method where the URI of the used consumed Thing Descriptions is provided manually (e.g., through user configuration or hard-coding in a script).
A discovery method where the physical location is considered (e.g., BLE, Audio Watermarking, ...).
A discovery method that can discover Things in local networks (e.g. SSDP, mDNS/DNS-SD, ...).
An Interaction Pattern to read a specific value of a Thing and optionally to write it.
An implementation of the mapping between Interaction in the TD Interaction Model (e.g., Property read) and specific operations of a protocol (e.g., HTTP GET).
A discovery method which supports lookup of remote Things also beyond network boundaries, for instance by using a directory service. The endpoint of the directory must be supported.
The application-facing programming interface provided by a Servient; comparable to the Web browser APIs.
Programming interface that allows scripts to expose local functionality as Things to WoT Clients.
A software stack that implements the WoT building blocks. A Servient can host and expose Things (server role) and/or consume Things (client role). Servients usually have multiple Protocol Bindings to enable interaction with different platforms.
Short for Thing Description.
A controlled Linked Data vocabulary by W3C WoT to tag the metadata of Things in the WoT Thing Description including communication metadata of WoT Binding Templates.
An abstraction of a physical or virtual entity whose metadata and interfaces are described by a WoT Thing Description. This entity can be an existing device augmented with a Thing Description, a logical component of a device that has a software stack that natively provides Thing Descriptions (see Servient), a local hardware component of a Servient, or a logical entity (e.g., location) that does not directly provide any software stack such as a room or building.
Structured data describing a Thing. A TD includes metadata, domain-specific metadata, a list of offered interactions, the supported protocol bindings for each interaction, and links to related Things. The Thing Description is built around a formal Interaction Model.
A directory service for TDs that provides a Web interface to register TDs (see draft-ietf-core-resource-directory) and look them up (e.g., using SPARQL queries or CoRE Link Format).
An entity that can connect with a network interface described by a WoT Thing Description (i.e., consume a Thing). WoT Clients usually implement multiple Protocol Bindings. WoT Client is also used to refer to a Servient in client role only.
The network-facing interface of a Thing as defined by its Thing Description.
The WoT object is the Scripting API entry point within a WoT Runtime. It provides methods to discover, consume, and expose Things.
A runtime system for application scripts with the WoT Scripting API. Implementing a WoT Runtime is optional for Servients.
An entity that exposes a network interface consistent with a WoT Thing Description. WoT Server is also used to refer to a Servient in server role only.
Acronym for Constrained Application Protocol [RFC7252]
CBOR Web Token draft-ietf-ace-cbor-web-token
A JSON document that is augmented with support for Linked Data by providing an @context property with a defining URI JSON-LD.
JSON Web Token [RFC7519]
The Resource Description Framework (RDF) of the Semantic Web rdf11-concepts