Knowledge-driven Architecture Composition

Interoperability is a major concern for Internet of Things device communication. Although there exist a lot of standardized network protocols, device payloads and interfaces are hard to standardize for every use case. From a global market perspective, vertical solutions such as the Apple HomePod exist where only certified devices and services are supported. Although different initiatives such as ZigBee that try to standardize the smart home domain exist, such standards are seldom universal (see “How Standards Proliferate” comic) and up-to-date. Hence, integration code must be written manually.

Permanent link to this comic:

Most of the available standards rely on the assumption that only one meaning is associated for each syntactic word (c.f. standardized vocabulary). In practice, this means that the homeowner himself must build up a platform model so that the interplay between available devices and automation rule satisfies his needs. Consequently, the “hard problem” of naming things in computer science also applies to the Internet of Things (see “Example for Syntax, Semantics and Pragmatics”). Certainly, such informal standards cannot be used as a basis for plug-and-play scenarios.

Example for Syntax, Semantics and Prgamatics

Current scientific solutions are driven by the goal of covering an application domain in a complete manner (e.g. SAWSDL). For example, ontology-based descriptions in Internet of Things systems must be created for every possible device interaction that may occur during runtime. Although such approaches facilitate automated component coupling scenarios (i.e. plug and play) regarding semantic interoperability practitioners currently rely on implementing adapters between devices and platforms. Hence, the additional formalization effort required by these approaches is perceived to be (too) high. Approaches such as configurable interface matching processes, fuzzy interface matching or semantic web service matching relax the completeness assumptions. However, the produced results contain probabilistic values that cannot serve as a reliable basis for generating and deploying software adapters at runtime.

To tackle this problem, we explore a novel integration method called “Knowledge-driven Architecture Composition” (KdAC) that relies on an incremental formalization process for interface semantics. This method explicitly allows for an incomplete domain model and supports an evolutionary instead of revolutionary definition without loosing plug-and-play functionality.

Knowledge-driven Architecture Composition

The method is applied by system integrators to formalize domain-specific knowledge without adapting component interface and abstracting from communication protocol.

By using declarative languages (e.g. JSONata), the inherited problem of partially incomplete integration knowledge can be tackled. The rationale for this is the usage of reasoning principles (e.g. from the field of logical artificial intelligence). For example, due to the transitive characteristics of converting temperature units, a reasoner could infer new integration knowledge. So, if the integration knowledge base contains the mathematical conversion formulas from Celsius to Fahrenheit and from Fahrenheit to Kelvin, a logic-based reasoner can directly infer the conversion function from Celsius to Kelvin. Based on the underlying principle such inference procedures and the reuse of machine-readable integration knowledge from previous integration cases can facilitate automated component composition (e.g. realizing a plug-and-play principle).

Automated component coupling is achievable as soon as all required interface functions and their data characteristics are present and/or can be deduced using a knowledge base. In other words, one can think of the reasoning process over integration knowledge as playing the game Sudoku: As soon as enough integration knowledge for an unknown and new integration case is present, the missing information can be calculated based on provided reasoning rules.

The novelty of this approach is formalizing semantic integration knowledge per use-case in a bottom-up manner. By focusing on integration knowledge instead of conforming to technological-oriented interface descriptions and standards, the method maximizes the impact for formalizing the semantic mappings as a concrete use-case must be present. Hence, formalization does only take place if it is specifically needed. The additional formalization effort in addition to implementing software adapters pays off as adapters for future devices can be generated (semi-) automatically.