ATEM 2006 SI
Call for Papers (source, 35 taggings)
Software languages play an important role in software development. Software languages are the artificial languages that are used to describe software systems at various abstraction levels. They are applied to describe requirements and designs for software, definitions of software architectures, and implementations of software systems. A huge variety of different technological spaces exist to describe languages: programming languagesT3D, software modeling languages, data modeling languages, domain-specific languagesT3C, ontology languageT3E, and others.
Software languages require a clear definition of the languages’ syntax and semantics, so that language processors can be implemented and other operations on language definitionsT5B are enabled such as language-based test-data generationT5C, language integrationT1D, and transformations between languagesT4B. Software languages have to be engineered to fulfill their specific tasks during the software development process. Model-based software development, when compared to more traditional approaches, particularly challenges such engineering in so far that more interrelations between different views on software systems (based on designated languages) have to be respected, and bridges between different languages for different purposes have to be built. There are various established techniques to handle software languages, such as, grammars for programming languages, metamodels for modeling languages, and ontologiesT3E for shared domain conceptualisations and language interrelations. What is missing is a capacious view on software languages that embraces a true life cycleT2A for software languages, and that also fully applies to problems of using different languages of different kinds with non-trivial interrelations in one context. Thus, a discipline of software language engineering is needed. Inspired by the well-known definition of IEEE for software engineering, Software Language Engineering can be defined as the application of a systematic, disciplined, quantifiable approach to the developmentT2A, use, and maintenanceT2B of languages in software engineering.
This special issue includes seven papers, addressing various aspects of Software Language Engineering. A major objective of the guest editors has been achieved – to cover a number of different communitiesT6D, namely (meta-) modeling, grammarware, and semantic web, and thereby give voice to different views on Software Language Engineering. Submissions were solicited by means of an open call that specifically, but not exclusively invited extended papers presented at the 3rd International Workshop on Metamodels, Schemas, Grammars and Ontologies (ateM 2006). All included papers are briefly described below.
- The paper ‘Extending Grammars and Metamodels for ReuseT1E, The Reuseware Approach’, by Jakob Henriksson, Florian Heidenreich, Jendrik Johannes, Steffen Zschaler, and Uwe Aßmann, describes an approach that captures some generic ideas of language designT1A in a language-independent manner: the ability to formulate partial “programs” and complete them later in different compositions. The approach enables designers of domain-specific languagesT3C to easily adopt the generic notion for the new language. The authors evaluate the approach by adding the concept of modules to the (Semantic) Web query language XcerptT5E.
- The paper ‘An OntologicalT3E Approach for the Semantic Recovery of TraceabilityT5G Links between Software Artifacts’, by Yonggang Zhang, René Witte, Juergen Rilling, and Volker Haarslev, describes an approach to the recovery of links between source-code artifacts and documentation in software systems, thereby helping with understanding and maintenance. The approach leverages ontological representationsT3E of source-code artifacts and documentationT2E. This paper provides a good example of a language engineering problem that spans several technological spaces. The benefits of using ontologies in software reverse engineeringT4C are clearly described.
- The paper ‘FormalisingT5D Model Transformation Rules for UML/MOF 2’, by Carsten Amelunxen and Andy Schürr, combines the MOF/OCL metamodeling approach to define domain-specificT3C modeling languages with graph transformation to specify the dynamic aspects (in fact, the dynamic semanticsT1C) of modeling languages and tools. By presenting a coherent formalisation of graph transformations in MOF environments, graph transformations are made available for MOF based language engineering. The described approach covers UML/MOF 2 including its sophisticated association concept.
- The paper ‘Learning Context Free Grammar Rules from a Set of Programs’, by Alpana Dubey, Pankaj Jalote, and Sanjeev Kumar Aggarwal, addresses the problem of grammar recoveryT4C, also known as grammar reverse engineeringT4C, which is an important problem of software maintenanceT2B, when one faces many legacy languagesT2A, without a grammar for some of the languages, or at least without a grammar for the specific dialect at hand. The paper develops and validates an approach to grammar recovery; grammars are inferred in an iterative and backtracking manner by using existing programs of the language under study as positive samples.
- The paper ‘Aspect-Oriented PrologT3D in a Language Processing Context’, by Wolfgang Lohmann, Günter Riedewald, and Guido Wachsmuth, exercises language engineering concepts in the context of Prolog, based on aspect-oriented programming (AOP) support for Prolog. That is, the paper modularises, composesT1D, and adapts grammar-oriented languages descriptions by representing them naturally in Prolog, and operating on them with an original AOP extension to Prolog. The approach is particularly suited to emphasis one important idea of Software Language Engineering – to treat language definitions as software artifacts, very similar to regular programs.
- The paper ‘Integration of Safety Analysis in Model Driven Software Development’, by Miguel A. de Miguel, Javier F. Briones, and Juan P. Silva, describes an approach to the integration of more classical modeling with the needs of safety analysis, so that these two modeling activities are no longer separatedT5G, that is, no longer based on disintegrated modeling languages. The approach provides an integrated notation of software architectures and safety to allow automatic generation of safety analyses during model-driven software development. The approach is based on UML-based metamodels with safety stereotypes and model transformationsT4B.
- The paper ‘Evaluating Formal PropertiesT5D of Feature Diagram Languages’, by Patrick Heymans, Pierre-Yves Schobbens, Jean-Christophe Trigaux, Yves Bontemps, Raimundas Matulevicius, and Andreas Classen, addresses the general problem of evaluating and comparingT5E (modeling) languages. More specifically, the class of languages for feature diagrams, as used for modeling software product linesT2C, is used as the language engineering exemplar. The comparison and evaluation of feature diagram languages is based on a general and formal method for comparative semantics of feature diagrams. The approach also leverages existing guidelines and methods in the context of formalising and evaluating (visual) languages.
The guest editors would like to thank all the submitting authors for the interest in the special issue, even though only a smaller part of all submissions could be selected for inclusion into the special issue. The guest editors are especially thankful to the referees for their timely reviews and expertise – their efforts were essential for the selection of the papers and increased the overall quality of the special issue. The guest editors are also grateful for the smooth cooperation with Paul Rowley, contact at IET Software, for his help in carrying out the substantial peer-review process and also for his patience.
This very special issue together with the name change of the ateM workshop in 2007 (to use the term Software Language Engineering) is the precursor of the International Conference on Software Language Engineering (SLE), with its first edition in 2008 (http://planet-sl.org/sle2008/). The SLE conference emerges not just from the ateM workshop series but also from the LDTA series (Language Descriptions, Tools, and Applications), which has been a satellite event at the European Joint Conferences on Theory and Practice of Software (ETAPS) for the last 8 years. Both workshops complement each other. The design of the SLE conference covers both, the more basic and technical aspects of LDTA (parsing, semantics, generic language technology), and the more abstract concerns of ateM (originally, reverse engineering of language descriptions; later, life cycle of software languages, relations between technological spaces for grammarware, schemaware, modeling, and meta-modeling). The International Conference on Software Language Engineering brings together researchers and practitioners to expand the frontiers of software language engineering.
List of Papers (7, source)
- Extending Grammars and Metamodels for Reuse: the Reuseware Approach (Jakob Henriksson, Florian Heidenreich, Jendrik Johannes, Steffen Zschaler, Uwe Aßmann)
- Ontological Approach for the Semantic Recovery of Traceability Links between Software Artefacts (Yonggang Zhang, René Witte, Juergen Rilling, Volker Haarslev)
- Formalising Model Transformation Rules for UML/MOF 2 (Carsten Amelunxen, Andy Schürr)
- Learning Context-Free Grammar Rules from a Set of Program (Alpana Dubey, Pankaj Jalote, Shubhani Aggarwal)
- Aspect-Oriented Prolog in a Language Processing Context (Wolfgang Lohmann, Günter Riedewald, Guido Wachsmuth)
- Integration of Safety Analysis in Model-Driven Software Development (Miguel A. de Miguel, Javier Fernández Briones, Juan Pedro Silva, Alejandro Alonso)
- Evaluating Formal Properties of Feature Diagram Languages (Patrick Heymans, Pierre-Yves Schobbens, Jean-Christophe Trigaux, Yves Bontemps, Raimundas Matulevičius, Andreas Claßen)
Organisers
