Tobias Walter

OntoDSL: An Ontology-Based Framework for Domain-Specific Languages

Domain-specific languages (DSLs) are high-level and should provide abstractions and notations for better understanding and easier modeling of applications of a special domain. Current shortcomings of DSLs include learning curve and formal semantics. This paper reports on a novel approach that allows the use of ontologies to describe DSLs. The formal semantics of OWL together with reasoning services allow for addressing constraint definition, progressive evaluation, suggestions, and debugging. The approach integrates existing metamodels, concrete syntaxes and a query language. A scenario in which domain models for network devices are created illustrates the development environment.

An ontology-based framework for domain-specific modeling

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.

Model driven engineering with ontology technologies

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.

Validation of families of business processes

A Software Product Line (SPL) is a set of programs that are developed as a whole and share a set of common features. Product lines variability is typically specified using problem space models (i.e., feature models), solution space models that specify the realization of functionality and mapping models that link problem and solution space artifacts. In this paper, we consider this concept in the scope of families of business processes, whose specificity is that the solution space is defined with business process models. Solution space models are typically specified as model templates, and thus in the rest of the paper we will refer to business process model templates. While the previous research tackled the concepts of families of business processes, there have been very limited research on their validation.

Combining DSLs and Ontologies Using Metamodel Integration

This paper reports on a case study where the domain specific language BEDSL for the description of network devices for computer networks is combined with the feature description language FODA used for defining the variability structure of product lines. Furthermore, annotations by fragments of the web ontology language OWL can be added. In essence, the approach is a three-way integration, which regards two documents written in BEDSL and FODA, respectively, and semantic OWL-annotations as three equally important views of the system under discussion. The integration of languages is done on the level of their metamodels. The standard metamodel of OWL 2 is merged with two self-developed metamodels for the respective domain specific languages. The merge is loss-free, i.e. the resulting merged model still contains all information from its parts. Thus, the BEDSL part can be used to visualize the network model, the FODA part still defines the feature structure of the corresponding product line and the OWL part can be extracted and fed into an OWL tool to assert the semantic conditions.

APIs à gogo: Automatic Generation of Ontology APIs

When developing application programming interfaces of ontologies that include many instances of ontology design patterns, developers of semantic web applications usually have to handle complex mappings between descriptions of information given by ontologies and object oriented representations of the same information. In current approaches, annotations on API source code handle these mappings, leading to problems with reuse and maintenance. We propose a domain-specific language to tackle these mappings in a platform independent way – agogo. Agogo provides improvements on software engineering quality attributes like usability, reusability, maintainability, and portability.

Joint language and domain engineering

In domain-specific development model-driven development environments play an important role. Most of these environments only provide support for language engineering, but do not consider the second dimension which is concerned with domain engineering. In this paper, we join the concerns of language engineering and domain engineering towards a new comprehensive approach of domain-specific development. It allows domain designers to build domain models containing both, types and instances, and it allows language designers for defining language metamodels. Furthermore, based on the integrated description logics the environment provides services for productive modeling in domain and language engineering.

OWLizing: transforming software models to ontologies

Today Model Driven Development (MDD) has a quite high importance in describing and building software systems. Although there are formal methodologies for defining software modeling languages we have analyzed some open challenges. Semantics of software modeling languages often are not defined within the language definition. In addition syntactic well-formedness constraints are often not explicitly defined in the language definition. To tackle these challenges we suggest the use of ontology technologies. Ontology technologies are used to extend the expressive of software modeling languages and to enable automated reasoning on all model artifacts in MDD. In this paper we show methodologies to bridge software modeling with ontology technologies and show applications where to adopt them.

Towards semantic modeling of network physical devices

One of the challenges faced by network management systems is the increasing need for consistent management of physical network equipment. We propose a solution where equipment is modelled using a dedicated Domain Specific Language (DSL) enriched with the power of logic-based reasoning services. This enables us to define a rich layer of semantics on top of the structural description of the devices. This way, the configuration related constraints are expressed declaratively, in a platform independent manner, and are managed in an integrated way with the structural model. The information kept in the model can then be used on runtime to give guidance to the system user.

A model-driven approach for using templates in OWL ontologies

Integrating model-driven development and semantic web resulted in metamodels and model-driven tools for the semantic web. However, these metamodels or tools do not provide dedicated support for dealing with templates in ontology engineering. Templates are useful for encapsulating knowledge and modeling recurrent sets of axioms like ontology design patterns. We propose an extension of existing metamodels and tools to support ontology engineers in modeling ontology templates. Our approach allows ontology engineers to keep template specifications as first-class citizens, reducing complexity and increasing reusability in ontology engineering. We demonstrate our approach with templates for ontology design patterns and well-known problems like domain closure.