View Source

This section provides an overview of the key tools that are expected to address the Semantic Infrastructure requirements. Tools are a combination of applications, user interfaces and services that address a specific Semantic Infrastructure requirement. The tool description provides a user view of how the tools may be used to perform specific tasks.

This section includes the following:

ECCF Registry and User Interface

The ECCF registry interface will provide a single interface for accessing all the artifacts and service metadata. Users will be able to use the interface to perform:

Artifact Search and Access

Search the registry for model
Search CTS 2 for existing value sets
Search the OID registry for an appropriate identifier route
Retrieve an existing model from the registry
Retrieve schemas and form definitions
Import a new model for annotation (binding to terminology and value-sets)
Retrieve the value set from CTS 2 and apply to the model attributes

Artifact Authoring

Create a new value set (leveraging terminology services) and manage existing artifacts
Register the object identifier with its metadata
Register a new artifact in the registry with its metadata (including ECCF specific information), traceability to support provenance
Link the models to existing models, domains, or both and classify artifacts
Constrain existing models
Constrain existing data-types
Link artifacts to service specifications
Dupport collaborative development of metadata

Artifact Governance and Lifecycle Management

Initiate artifact workflow
Monitor the workflow process
Allow curators to set the status of a model and receive change notifications
Customize review and approval workflows
Govern collaborative development

Artifact Analysis

Execute semantic queries for search and analysis

Access Control and Policy Management

Establish templates and policies that can be applied to artifacts
Link the users security and access rights to a particular governance and workflow
Execute semantic queries for analysis
Identify dependencies

Search and Access Services

Discover services
Execute complex queries to identify services
Discover contracts at runtime

Administer Services and Specifications

Create a new service specification
Create and edit service metadata
Link the artifacts to the service specification
Construct conformance statements
Run validations on specification and supporting artifacts
Apply constraints, rules and policies
Constrain and reuse existing specifications and artifacts

Analyze Services

Execute semantic queries for analysis
Perform impact analysis to identify dependencies and constraints

Service Governance and Workflows

Initiate service specification governance
Monitor the workflow and approval process
Allow governance team to set the status of specification and promote
Manage versioning and localization of the service specifications
Govern collaborative development

Plug-ins, Loaders and Miscellaneous Development Tools

Plug-ins and development tools are extensions to existing tools to support better integration with the ECCF registry:

Publish artifacts from eclipse and other modeling tools to the ECCF registry
Publish content from external tools to the ECCF registry, with support for topic maps and DITA
Extract and load metadata from artifacts into registry

Forms Editor

An end user tool for creating and editing forms:

Create form definitions
Retrieve models, data-types and value-sets
Define skip patterns, layout and display options
Publish forms to ECCF registry
Reuse and leverage predefined templates

Conformance Testing Framework

A testing framework for developing automated test scripts that can be executed against an artifact or service.

Retrieve artifact metadata and conformance statements
Generate test scripts
Execute conformance tests
Generate conformance report

Knowledge Based Systems Support Tools

A set of knowledge engineering tools to support reasoning and inference use cases.

Knowledge Representation Definition
Rule Pattern Definition
Domain Model Development
Knowledge Base Model Definition
Fact Generation and Mapping tooling
Rule Generation tooling
Reasoner Framework for Standard Knowledge-based System Development
Automated Reasoning Service Publication

Legend for Diagram Above

Components for Development
Box name:UML Transformation	The UML transformation process takes a standard UML representation (XMI) of a model and performs analysis to determine semantics and definitions.
Box name:XML Transformation	The XML transformation process takes XML Schemas and XML instances to generate and determine semantics and definitions.
Box name:RDF/OWL Librarian	The librarian is responsible for knowing what definitions are represented in the registry. In addition, the librarian is responsible for versioning and representation of the governance process.
Box name:Transformation/Extraction Cache Controller	The cache controller is used to improve performance and interactions of the various components. Since reasoning systems may require the merging of large amounts of knowledge, the controller will prevent unnecessary fetching operations.
Box name:DIFF Tool	The DIFF tool provides a number of functional behaviors such as determining differences between two versions of semantic representations. In addition, the diff tool looks at the semantics to determine if two systems of representations may have common areas of interest.
Box name:Reasoner Controller	Manages the reasoner configurations and implementations so when called upon they are properly configured.
Box name:Reasoner Orchestration Tool	The orchestration tool provides integration between reasoners. This allows for the staging of reasoning systems to allow for concurrent or parallel processing of reasoning systems..
Box name:Reasoner Session Manager	Since users may perform interaction with the reasoning systems with specific knowledge stores and reasoner configurations, the session manager maintains the state and processes until the user or system no longer requires it.
Box name:ECCF KM API	The set of functional APIs that can be called by applications.
Box name:ECCF KM Remote Service API	The set of remote service APIs that are called by applications. These set of service calls include appropriate implementations such as SOAP and RESTful services.
Box name:ECCF KM Web Interface	The Web interface is a web application that users can use to interact with the Knowledge Manager. From this application users can upload knowledge sources for processing by the reasoners, download semantic representations of processed models and schemas, as well as perform direct queries against the knowledge stores.
Data Stores
Box name:RDBMS Store	This is information stored in traditional RDBMS stores with traditional schemas. Semantic access to these system will be performed using the open source tools.
Box name:Triple Store	The most flexible representation of semantic information is stored in a triple store. There are multiple possible physical representations including files, RDBMS triple stores, and dedicated high performance triple stores.
Open source components
Box name:Jena	Jena is a standard interface tool that allows for the access of triple store information in RDF and OWL formats. Jena is a very flexible tool with the ability to interact with the stores with various reasoners.
Box name:ARQ (SPARQL)	ARQ is an implementation of the SPARQL language. SPARQL provides a standardized query language for interacting with triple stores.
Box name:Pellet	Pellet is an OWL 2 reasoner. Pellet provides standard and reasoning services for OWL ontologies.
Box name:FaCT ++	FaCT++ is an OWL DL reasoner (partially OWL 2), is implemented in C++ and uses optimized tableaux algorithms.
Box name\:D2RQ	A tool, which works with traditional RDBMS structures and presents them using RDF semantics. This allows for SPARQL queries of RDMS data, as well as integration with reasoning systems.
Box name:Other Reasoners	The jena tool provides for integrations with alternative reasonsers, which can be determined later.