No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Semi-automated integration of domain ontologies to DSL meta-models
Abstract
This paper investigates the use of ontologies for the development of
Domain-Specific Languages (DSL). In Model-based Software Development
(MBSD), ontologies as formal models are mostly used in the phase of domain
analysis as formal representations of domain models and requirements of a
system. In this paper, we extend this view by introducing a concept of a DSL
meta-model ontology that is defined as consisting of system ontology of a
MSDB tool linked to one or more domain ontologies and external software
artefacts. According to the solution presented in this paper, the given domain
ontologies are semi-automatically integrated into a DSL meta-model using a set
of transformations between constructs of ontology modelling language OWL
and a modelling language used for representing DSL meta-models. This
approach enables a dynamic semantic composition of a DSL meta-model and is
prototypically implemented in Java as an extension to the DSL development
tool CoCoViLa.
... The knowledge that is described in ontology is separated from the execution logic of software system. This makes it possible to keep domain knowledge only in the ontology and query the ontology for getting specific knowledge of a domain (Gasevic et al., 2009;Haav and Ojamaa, 2017;Hoehndorf et al., 2009;Katasonov, 2012;Pan et al., 2013). ...
... The working groups at the OMG and the W3C have carried out initial steps towards ODSD in 2006(OMG, 2006. Since then many researchers have provided different ways of the use of ontologies for improvement and enhancement of traditional soft-ware engineering processes as well as of MBSD (Assmann et al., 2010;Pan et al., 2013;Staab et al., 2010;Katasonov, 2012;Haav and Ojamaa, 2017). ...
... 2. The ODM hierarchy of models. Pan et al., 2013;Staab et al., 2010;Katasonov, 2012;Haav and Ojamaa, 2017). These works have been basically motivated by the fact that MDA-based languages are not logicbased and do not enable reasoning. ...
Ontology Driven Software Development (ODSD) combines traditional Model Based
Software Development (MBSD) techniques with ontology technology in order to provide extensions
to and advantages over MBSD. The goal of the paper is to identify current ODSD approaches
and to provide qualitative and comparative analysis of the collection of identified approaches. Main
research questions of the paper concern the ways of how ontologies are integrated toMBSD process
and how their usage advances MBSD. Benefits and challenges of each of the discussed approaches
are presented. The analysis is based on literature and projects reviews in the fields of ontology engineering,
MBSD and ODSD. The result of the analysis provides understanding of what is the role of
ontologies in ODSD and shows whether application of ontology technologies to the MBSD process
gives rise to a new paradigm called consistency preserving software development or not.
... 3. The DSL Meta-Model Ontology Based Approach. OWL ontologies are integrated in the model-based software technology that uses that uses automated program synthesis for generating software from models [31]. 4. The Three ontology method [32] that uses domain, task and top-level ontologies for ontological modeling of a software system. ...
The paper is devoted to research into methods for requirements elicita-tion. From our perspective, the use of ontology engineering is particularly interesting. The author focuses his attention on selected aspects of ontology engineering , resulting from the needs of his doctoral thesis, organized by the Design Science Research paradigm. The article seeks to recognize a certain level of interplay between ontology engineering and individual tasks of the process of requirements elicitation (a synergy). Therefore, it aims to explain possible expectations for ontology engineering, which result from the specific features of the process of requirements elicitation. In order to identify the guidelines for the developing domain ontologies based on the requirements elicitation process. The originality of the article results from the consideration of the interplay between ontology engineering and requirements engineering, relative to the context of software engineering. As a result, the software engineering layers propagated by Pressman have been extended to include another layer of management philosophy. The rationale behind this was the noticing of the impact of other concepts of philosophy on this work, such as axiology or epistemology.
In this chapter, we present a framework for the evaluation and (re)design of modeling languages. In our approach, this property can be systematically evaluated by comparing a concrete representation of the worldview underlying the language (captured in the language’s meta-model), with an explicit and formal representation of a conceptualization of that domain (a reference ontology). Moreover, we elaborate on formal characterizations for the notions of reference ontology, conceptualization and meta-model, as well as on the relations between them. By doing this, we can also formally define the relation between the state of affairs in reality deemed possible by an ontology and the grammatical models admitted by a modeling language. The precise characterization of this relation allows for a systematic improvement of a modeling language by incorporating ontological axioms as grammatical constraints in the language’s meta-model. Furthermore, we demonstrate how an approach based on visual simulation could be used to assess this relation, i.e., to evaluate the distance between the valid models of a language and the intended models according to the underlying conceptualization. Finally, we demonstrate how the use of a system of formal ontological properties can be systematically exploited in the design of pragmatically efficient domain-specific visual languages.
A way of combining object-oriented and structural paradigms of software composition is demonstrated in a tool for generative programming. Metaclasses are introduced that are components with specifications called metainterfaces. Automatic code generation is used that is based on structural synthesis of programs. This guarantees that problems of handling data dependencies, order of application of components, usage of higher-order control structures etc are handled automatically. Specifications can be written either in a specification language or given visually on an architectural level. The tool is Java-based and portable.
Ontologies constitute formal models of some aspect of the world that may be used for drawing interesting logical conclusions
even for large models. Software models capture relevant characteristics of a software artifact to be developed, yet, most
often these software models have limited formal semantics, or the underlying (often graphical) software language varies from
case to case in a way that makes it hard if not impossible to fix its semantics. In this contribution, we survey the use of
ontology technologies for software modeling in order to carry over advantages from ontology technologies to the software modeling
domain. It will turn out that ontology-based metamodels constitute a core means for exploiting expressive ontology reasoning
in the software modeling domain while remaining flexible enough to accommodate varying needs of software modelers.
The Web Ontology Language (OWL) provides a modelling paradigm that is especially well suited for developing models of large, structurally complex domains such as those found in Health Care and the Life Sciences. OWL's declarative nature combined with powerful reasoning tools has effectively supported the development of very large and complex anatomy, disease, and clinical ontologies. OWL, however, is not a programming language, so using these models in applications necessitates both a technical means of integrating OWL models with programs and considerable methodological sophistication in knowing how to integrate them. In this paper, we present an analytical framework for evaluating various OWL-Java combination approaches. We have developed a software framework for what we call hybrid modelling , that is, building models in which part of the model exists and is developed directly in Java and part of the model exists and is developed directly in OWL. We analyse the advantages and disadvantages of hybrid modelling both in comparison to other approaches and by means of a case study of a large medical records system.
Ontologies are widely proposed for solving semantic interoperability problems in e-government domain. However, less attention is paid on methodological issues of ontology development in this domain. These are not sufficiently solved. Existing approaches in ontology development are technically very demanding and require long learning curve and are therefore inefficient for this purpose. E-government domain ontologies could be efficiently developed by domain experts rather than ontology engineers. The paper proposes a novel ontology development methodology for construction of light-weight domain ontologies by bringing ontology modeling closer to domain experts that are actual domain knowledge holders. The approach is illustrated and evaluated by development of a network of e-government domain ontologies used for achieving semantic interoperability of state information systems (IS) in Estonia.
Domain-specific languages (DSLs) are computer (programming, modeling, specification) languages devoted to solving problems in a specific domain. The development of a DSL includes the following phases: decision, analysis, design, implementation, testing, deployment, and maintenance. The least-known and least examined are analysis and design. Although various formal methodologies exist, domain analysis is still done informally most of the time. A common reason why formal methodologies are not used as often as they could be is that they are very demanding. Instead of developing a new, less complex methodology, we propose that domain analysis could be replaced with a previously existing analysis in another form. A particularly suitable form is the use of ontologies. This paper focuses on ontology-based domain analysis and how it can be incorporated into the DSL design phase. We will present the preliminary results of the Ontology2DSL framework, which can be used to help transform ontology to a DSL grammar incorporating concepts from a domain.
This paper addresses a high level semantic integration of software artefacts for the development of Domain Specific Languages (DSL). The solution presented in the paper utilizes a concept of DSL meta-model ontology that is defined in the paper as consisting of a system ontology linked to one or more domain ontologies. It enables dynamic semantic integration of software artefacts for the composition of a DSL meta-model. The approach is prototypically implemented in Java as an extension to the DSL development tool CoCoViLa.
This paper addresses the problem of alignment of domain ontologies and meta-models of Domain Specific Languages (DSL) in order to facilitate the DSL development process by formal methods. The solution presented in this paper automatically generates design templates of a DSL meta-model that are consistent with a given domain ontology represented in OWL DL. Consistency of alignment is ensured by predefined mapping rules between constructs of ontology modelling language OWL DL and a modelling language used for representing DSL meta-models. The approach is implemented as an extension to the CoCoViLa system and the CoCoViLa modelling language is used for representing DSL meta-models. The evaluation of the provided method is carried out by developing the DSL for the IT risk analysis and management domain.
This paper introduces a novel framework for Ontology-Driven Software Engineering. This framework is grounded on the prior related work that studied the interplay between the model-driven engineering and the ontological modeling. Our framework makes a contribution by incorporating a more flexible means for ontological modeling that also has a higher performance in processing, and by incorporating a wider range of ontology types into ODSE. As a result, it extends the power and speed of the classification and the model consistency checking ontological services enabled by the prior work, and brings new ontological services: semantic search in model repositories, three kinds of semi-automated model composition services: task-based, result-based, and opportunistic, and the policy enforcement service. The primary intended use for this framework is to be implemented as part of model-driven engineering tools to support software engineers. We describe our reference implementation of such a tool called Smart Modeller, and report on a performance evaluation of our framework carried out with the help of it.
A flexible Java-based simulation platform that includes both continuous-time and discrete event simulation engines and is intended for applications in a variety of domains is presented. The platform supports visual and model-based software development and uses structural synthesis of programs for translating declarative specifications of simulation problems into executable code. Rich components are an important concept of the work. They are implemented as Java classes with additional specifications for program synthesis, and include visual representations as well as daemons supporting continuous interaction with the user during the simulation. The platform is developed as an open-source software, and its extensions can be written in Java and included into simulation packages.
Domain-specific languages (DSLs) provide abstractions and notations for better understanding and easier modeling of applications in a special domain. Current shortcomings of DSLs include learning curve and formal semantics. This paper reports on a framework that allows the use of ontology technologies to describe and reason on DSLs. The formal semantics of OWL together with reasoning services allows for addressing constraint definition, progressive evaluation, suggestions, and debugging. The approach integrates existing metamodels and concrete syntaxes in a new technical space. A scenario in which domain models for network devices are created illustrates the framework.
The design stage of domain-specific language development, which includes domain analysis, has not received as much attention
compared to the subsequent stage of language implementation. This paper investigates the use of ontology in domain analysis
for the development of a domain-specific language. The standard process of ontology development is investigated as an aid
to determine the pertinent information regarding the domain (e.g., the conceptualization of the domain and the common and
variable elements of the domain) that should be modeled in a language for the domain. Our observations suggest that ontology
assists in the initial phase of domain understanding and can be combined with further formal domain analysis methods during
the development of a domain-specific language.
Logic programming is understood as the use of constructive proofs for building correct programs. We illustrate the application of this approach in the framework of propositional calculus and outline the PRIZ programming system, which has intuitionistic propositional calculus as its logical basis. The relation of the deductive program synthesis to constraint propagation and the introduction of parallelism are considered.
We present a constructive description of the automatic program synthesis method used in the PRIZ programming system. We give a justification of the method by proving the completeness of its inference rules for the class of constructive theories, and we present rules for transforming any intuitionistic propositional formula into a form suitable for these inference rules.
Model-driven software development facilitates faster and more flexible integration of information and communication systems.
It divides system descriptions into models of different view points and abstraction levels. To effectively realize cross-organisational
collaborations, it is an important prerequisite to exchange models between different modelling languages and tools. Knowledge
is captured in model transformations, which are continuously adjusted to new modelling formats and tools. However, interoperability
problems in modelling can hardly be overcome by solutions that essentially operate at syntactical level. This paper presents
a novel approach using the capabilities of semantic technologies in order to improve cross-organisational modelling by automatic
generation and evolution of model transformations.
Ontologies are no silver bullet. They can be employed in the software process as descriptive standardized domain models, domain-specific languages, and modelling (description) languages. However, they should not be mingled with specifications of software systems. In MDE, both forms of models are needed and complement each other. It is time to develop appropriate mega-models that clarify the role of ontologies in MDE. This chapter has presented one approach; however, this can be only an intermediate step, because we restricted ourselves to the standard IRDS metapyramid. Other, more sophisticated meta-pyramids exist and must be extended to be ontology-aware.
Eclipse Modeling Project: A Domain-Specific Language (DSL) Toolkit
- R Gronback
Gronback, R. (2009) Eclipse Modeling Project: A Domain-Specific Language (DSL) Toolkit.
Addison-Wesley Professional.