 | Anneke Kleppe University of Twente The Netherlands |
| 09:10-09:40 | A Language Description is More than a Metamodel | ||
| Within the context of (software) language engineering, language descriptions are considered first class citizens. One of the ways to describe languages is by means of a metamodel, which represents the abstract syntax of the language. Unfortunately, in this process many language engineers forget the fact that a language also needs a concrete syntax and a semantics. In this paper I argue that neither of these can be discarded from a language description. In a good language description the abstract syntax is the central element, which functions as pivot between concrete syntax and semantics. Furthermore, both concrete syntax and semantics should be described in a well-defined formalism. | ||
| 09:40-10:00 | Making Modeling Languages Fit for Model-Driven Development | ||
| In this position statement I argue that a modeling language that aspires to be used in a model-driven development context must fulfill more requirements than traditional notations that have been primarily used for solution sketching. I enumerate some of these requirements, evaluate to what extent they are addressed by the UML, and suggest how the UML could be enhanced in order to become a modeling language that adequately supports model-driven development. | ||
| 10:00-10:30 | A Comparison of Standard Compliant Ways to Define Domain Specific Languages | ||||
| Domain specific languages (DSLs) are of increasing importance for today's software development processes. Their area of application ranges from process modeling over architecture description and system design to behavioral specification and simulation. There are numerous approaches for the definition and implementation of DSLs. Among others, the OMG offers UML profiles as a leightweight extension of a predefined multi-purpose language and MOF as a metamodeling language, which can be used to define DSLs from scratch. This contribution investigates various approaches to define DSLs, focusing on architecural description languages (ADLs) as an example. Besides the usage of UML profiles and the definition of a completely new language with MOF, the adaption of the UML based on a metamodel extension is also considered. As a consequence of the shortcomings depicted for the different approaches, we suggest to combine UML profiles and metamodeling in order to compensate their weaknesses and take advantage of their benefits. | ||||
| 11:00-11:30 | Metamodel-based UML Notations for Domain-specific Languages | ||||
| We present a metamodel-based approach for specifying UML notations for domain-specific modeling languages. Traditionally, domain specific languages are either defined by UML profiles or using metamodels. We provide a generic integration of these two methods supporting arbitrary UML profiles and metamodels. Our approach provides a bi-directional mapping between the UML notation and the metamodel of the domain specific language. We use OCL constraints that are embedded into the metamodel, for describing the mapping between the UML notation and the metamodel. Moreover, we describe an implementation, as ArgoUML-plugin, for arbitrary SecureUML dialects. | ||||
| 11:30-11:50 | Towards Semantic Integration of Multiple Domain-Specific Languages Using Ontological Foundations | ||||
| The paradigm of Model-Driven Software Development (MDSD) enables language engineers to provide domain-specific structures that are then used by system developers to engineer applications. Through a higher level of abstraction and a limited set of concepts, these languages facilitate effective and fast development. However, current model-driven approaches usually employ metamodeling for language specification. This prevents expressing semantic interconnections and dependencies between participating DSLs. Often, this information is implicitly hidden in model transformations and code generators which hampers reusability of DSLs and associated assets. As an answer, we present an approach that facilitates the integration of domain-specific languages on a semantic level by mapping language constructs to concepts in an upper ontology. In contrast to previous approaches, we concentrate on the system design phase. We present a customized upper ontology for software modeling and demonstrate the feasibility of our approach in a case study. | ||||
| 11:50-12:10 | Prototyping Domain-Specific Languages for Wireless Sensor Networks | ||
| The development of software for wireless sensor networks is involved and complex. This does not only impose much work on programmers but also prevents domain experts from directly contributing parts of the software. Domain-specific languages may help with these problems---if they are inexpensive to define, have a syntax that domain experts understand, and creating simulations for them is easy. We propose a language engineering approach that meets these requirements and thus allows rapid prototyping of domain-specific languages. We present our realization based on Scheme and Eclipse EMF and present first experiences from the prototyping of a stream-oriented language for the description of earthquake detection algorithms. | ||
| 12:10-12:30 | CoCloRep: A DSL for Code Clones | ||||||||
| Code clones are pieces of code that are duplicated in multiple locations in the source code of a software application. The existence of these clones and the availability of clone detection tools to find them lend to the need for techniques to analyze the clones in an effort to enhance the quality of the source code. This paper describes an investigation into the development of CoCloRep, a Domain-Specific Language (DSL) for the representation of code clones. The benefits of Model-Driven Engineering (MDE) in this context are observed through the use of model transformations on the clones that are represented by instances of this DSL. These transformations provide a means to analyze the clones. The DSL is developed in the AMMA platform (ATLAS Model Management Architecture), which is a modeling tool that provides features through its own DSLs to specify metamodels and to perform transformations on models. | ||||||||
| 14:00-14:30 | Designing Syntax Embeddings and Assimilations for Language Libraries | ||||
| Language libraries extend regular libraries with domain-specific notation. More precisely, a language library is a combination of a domain-specific language embedded in the general-purpose host language, a regular library implementing the underlying functionality, and an assimilation transformation that maps embedded DSL fragments to host language code. While the basic architecture for realizing language libraries is the same for all applications, there are many design choices to be made in the design of a particular combination of library, guest language syntax, host language, and assimilation. In this paper, we present a systematic analysis of the design space for syntax embeddings and assimilations for the realization of language libraries. The contribution of this paper is an overview of the state-of-the-art providing insight in the design space and research questions in language library realization, in particular, the identification of research issues for realizing an independently extensible language library framework. | ||||
| 14:30-14:50 | Model-based Aspect Weaver Construction | ||||||
| This paper describes an approach that combines model engineering with program transformation techniques to construct aspect weavers for general-purpose programming languages. The front-end of the weaver uses a high-level language (i.e., a domain-specific aspect language) to specify aspects and is designed with a metamodel-based approach using the AMMA toolsuite. The back-end of the weaver uses transformation rules, which are generated from these high-level aspect specifications, to perform the actual low-level weaving. Both the aspect specification (front-end) and transformation rules (back-end) are captured as models within the AMMA platform. The translation from source aspect model to target transformation model is achieved using ATL, which is a model transformation language. | ||||||
| 14:50-15:10 | An Algebraic Approach for Composing Model Transformations in QVT | ||||||||
| The ability to orchestrate different transformations in a flexible and reliable manner is a major challenge in MDE. Most of the current work on model transformations seems essentially operational and executable in nature. Executable descriptions are necessary from the point of view of implementations; but from a conceptual point of view, transformations can also be viewed as descriptive models. In particular, regarding the transformation composition problem, most approaches are focused only on the operational aspects of the composition, neglecting its descriptive side. Such incomplete view on the composition issue provides suitable answers to a wide range of practical needs. However it does not cover the entire problem’s spectrum. In this article we describe how the algebraic theory of problems formalism is applied as a basis to build a mathematical foundation for the transformation composition problem embracing both dimensions (descriptive and operational). We report the implementation of a software tool supporting the algebraic formalization. | ||||||||
| 15:10-15:30 | Text-based Modeling | ||||||||||
| As modeling becomes a crucial activity in software development the question may be asked whether currently used graphical representations are the best option to model systems efficiently. This position paper discusses the advantages of text-based modeling over commonly used graphical representations. This discussion is inspired through the advent of new and efficient development tools, like Eclipse in the mainstream of development projects. The discussion is illustrated by showing a textual version of UML state machines as Eclipse plugins. | ||||||||||
| 16:00-16:20 | Biological Data Migration Using a Model-Driven Approach | ||||||||||||
| This paper shows how Model-Driven Software Development (MDSD) can be applied in the bioinformatics field since biological data structures can be easily expressed by means of models. The existence of several heterogeneous data sources is usual in the bioinformatics context. In order to validate the information stored in these data sources, several formalisms and simulation tools have been adopted. The process of importing data from the source databases and introducing it in the simulation tools is usually done by hand. This work describes how to overcome this drawback by applying MDSD techniques (e.g. model transformations). Such techniques allow us to automate the data migration process between source databases and simulation tools, making the transformation process independent of the data persistence format, obtaining more modular tools and generating traceability information automatically. | ||||||||||||
| 16:20-16:50 | Zhi# - Programming Language Inherent Support for Ontologies | ||
| XML Schema Definition (XSD) and the Web Ontology Language (OWL) have been widely used to define programming language independent data types and to conceptualize knowledge. However, writing software that operates on XML instance documents and on ontological knowledge bases still suffers from a lack of compile time support for XSD and OWL. In this paper, a novel compiler framework is presented that facilitates the cooperative usage of external type systems with C#. For the resulting programming language Zhi#, XSD and OWL compiler plug-ins were implemented in order to provide static type checking for constrained atomic value types and ontologies. XSD constraining facets and ontological inference rules could be integrated with host language features such as method overwriting. Zhi# programs are compiled to conventional C# and are interoperable with .NET assemblies. | ||
