This page is a sub-page of our page on TELL ME.

///////

The TELLME Reference Architecture:

Intentional and realizational possibilities:

Abstract interfaces for the TELLME system (large):

Interacting through an Abstract Service Interface

We will illustrate service interoperability with an example from the cultural heritage sector, where interoperability of services presents huge challenges due to the underlying heterogeneity of the involved data structures. Two of the major representational standards for cultural heritage information, CIDOC and Spectrum, decided in 2015 to align their information models.

TELL ME D4.4 Figure 5: Service interoperability pattern

One way to do so, would be to “servicify” both of them by having them implement a common Abstract Service Interface (ASI) e.g., as depicted in Figure 5 where the ASI is called “Service”.

The implicit context of application of this interface is a specific service of type Service that we can call theService, and which has declared the following operational interface

• InputOutput whichOutput( ):
• InputOutput  whichInput( );
• Stakeholders forWhom( );
• Purpose why( );
• Workflow how( );
• Support fromWhom( );
• Constraints adheringToWhat( );
• PreConditions whichPreconditions( );
• PostConditions whichPostConditions( );

In the underlying programming language, typically Java or C++, you can then ask these interface questions to the service in question, by writing theService.fromWhom( ), theService.adheringToWhat( ), etc.. The result of this question/call to the service would then be of the type listed as the first words of the bulleted list. Hence, in our example, we would get back something of types Support respectively Constraints.

Abstract Service Factory:

TELL ME D4.4 Figure 6: An Abstract Service Factory (ASF)

Notation: GLAM is an achronym for Galleries, Libraries, Archives, Museums.

Notice how the GLAM_Client can create a CurationService purely by interacting with the abstract service classes ServiceFactory and CurationService. Therefore the GLAM_Client becomes more flexible since it is shielded from “concrete” (= realizational = implementational) knowledge about what kind of representation standard that is actually being used by the underlying system.

To ensure polymorphic (= “subtype-ignorant”) data binding, each representational standard must implement its own version of each of the abstract interface classes at the top of the type hierarchies shown in Figure 7.

TELL ME D4.4 Figure 7: Polymorphic data type hierarchies