OntologySummit2011: Application Framework Community Input (2LKD)
Ontology Application Framework (2OMH)
(2OL2)
The objective of the framework is to provide a common terminology for describing applications of ontologies and the benefits that ontologies deliver within these applications. In addition to classifying ontology applications, this provides the basis for benchmarks and the ability to compare different applications of ontologies. (2OL3)
Dimensions (2OMF)
- Functionality (2OL5)
How are the ontologies used? (2OLL)
- Matching / mapping of concepts (2OLM)
- Automated inference (2OLN)
- Classification (2OLO)
- Specification (2OL6)
- Terminological Clarification (2RFU)
- Architecture (2OLP)
Are the ontologies being applied to a single system or are they being used among multiple systems? (2OL7)
- When are the ontologies used? (2OLQ)
Are the ontologies used at design time for the system or are they used by the system at runtime? (2OL8)
- Who is using the ontologies? (2OLR)
- Ontology Author (2OLS)
- Data Author (2OLT)
- Application Developer (2OLU)
- Application User (2OLV)
- Knowledge Worker (2OL9)
- What ontologies are used? (2OLA)
- Problem addressed Why are the ontologies being used? (2OLB)
- Benefit What is the impact of the ontologies on the functional/nonfunctional requirements of existing system? (2OLW)
- The ontologies support new functional requirements within system. (2OLX)
- The ontologies support nonfunctional requirements of the system: quality, performance, maintenance, cost, portability, reliability, scalability, robustness, usability, and extensibility. (2OLY)
The value metrics for evaluating the benefits associated with nonfunctional requirements are the same metrics used for nonfunctional requirements themselves. (2OLZ)
- Enterprise Context (2RFV)
- Core Process Integration: An enterprise will have at least one and maybe several core processes. These are the processes the execution of which are the purpose of the enterprise. In business they are often around the provision of goods or services to customers. These core processes are supported by information systems, and information needs to pass between them in order to efficiently perform the overall process, integrating the disparate systems involved. A key part of this will include Master Data Management so that all the systems use the same identification for key things like products and customers. (2RFW)
- Lifecycle Integration: There will be a number of things needed to support the core processes, such as factories and vehicles, each of which has a lifecycle that needs to be integrated. Particularly with large and long lived assets like factories and ships, information needs to be passed between lifecycle stages (e.g. design to construction, design and construction to operations, etc) and between the information systems that support the different processes in those different stages. (2RFX)
- Supply Chain Integration: When enterprises procure goods in particular, but also services, they do not just capture price information, part of the product will be information about it, and its use. This information needs to be integrated within the systems that are involved with the operation and use of those products. (2RFY)
- Business Intelligence (Performance Management): To understand how well an enterprise is performing its processes you need to be able to analyse the data that arises from the performance of its processes. This usually involves collecting and integrating the data from multiple systems, and populating star or snowflake schemas so that for example sales can be analysed by customer type, by product type, by geographic region, by volume, by value, by profitability etc. (2RFZ)
(2OLC)
(2OLD)
An Initial Classification of Ontology Applications (2OMG)
We can use the above ``dimensions" to identify the following classes of applications. (2OM0)
- Integration (2OM1)
In this class of applications, the primary functionality is the matching and mapping of concepts, while the primary architecture is within a set of multiple systems. Ontologies are typically used at runtime by application developers (who are in the best position to write translators among the systems). (2PQO)
- information integration Multiple information resources are combined using ontologies at runtime to match concepts with similar meaning. (2OM2)
Examples: web service composition, mashups, information aggregation, data fusion, linked data (2PQP)
- database integration Queries that require multiple databases are specified using common ontologies and data schema are matched using these ontologies at runtime. (2OM3)
Examples: applications of biomedical ontologies (2PQQ)
- software interoperability Software systems exchange sentences that are written using ontologies. Each software software uses an ontology (either its own or a set of shared ontology) to translate the exchanged sentences at runtime. (2OM4)
- software access Ontologies provide a uniform conceptual interface to multiple software applications. (2OLE)
- Decision Support (2OLF)
In this class of applications, automated inference is the primary functionality. Ontologies are used at runtime, typically by knowledge workers and application users. With respect to the architecture, ontologies are used within a single system. (2PQR)
- deduction from Axioms via Theorem Provers The axioms of the ontology and domain theories are used to entail queries using a general-purpose automated theorem prover at runtime. (2OM5)
Examples of automated theorem provers: Racer, Prover9 (2PQS)
- deduction from Axioms via Special-Purpose Reasoners Special-purpose algorithms are implemented that are sound (and possibly complete) with respect to the set of sentences that are entailed/satisfied by the ontology at runtime. (2OM6)
Examples: temporal reasoners, scheduling algorithms (2PQT)
- validation of integrity constraints (2OLG)
- Semantic Augmentation (2OM7)
Applications in this class focus on using the ontologies as the basis for specification within a single system. As a result, the ontologies are used primarily at runtime by knowledge workers and application developers. (2PQU)
- ontology-based algorithms Existing algorithms use classes and relations within ontologies at design time to define search space and specify heuristics to guide search (2OM8)
Examples: information retrieval, NLP (2PQV)
- ontology embedded into software Object-oriented implementation (e.g. Java classes) generated from classes in the ontology at design time. (2OM9)
- model-driven design Design (enterprise or manufacturing artefact) is specified using the ontology and exported into software. (2OMA)
- ontology-based standards Terminology within a standard is axiomatized by an ontology. Conformance with the standard is evaluated with respect to this axiomatization. (2OLH)
Examples: Units of Measure, CL axiomatization of UML (2PQW)
- Adding semantic meaning to an existing system. (2PQX)
- Knowledge Management (2OMB)
In this class of applications, knowledge workers use ontologies for classification within a single system. (2PQY)
- discovery Patterns in data are identified by matching against the classes, relations, and axioms of the ontology (2OMC)
- categorization of information resources An ontology is used to organize unstructured information resources by identifying classes and relations within the ontology with terms that appear in the resources. (2OMD)
Examples: Indexing, data warehouses, semantic annotation (2PQZ)
- knowledge capture Classes in the ontology provide templates for gathering knowledge from subject matter experts. (2OME)
(2OLI)