Software as a Service (SaaS) and the possibility to compose Web services provisioned over the Internet are important assets for a service-oriented architecture (SOA). However, the complexity and time for developing and provisioning a composite service is very high and it is generally an error-prone task. In this paper we address these issues by describing a semi-automated “Composition as a Service” (CAAS) approach combined with a domain-specific language called VCL (Vienna Composition Language). The proposed approach facilitates rapid development and provisioning of composite services by specifying what to compose in a constraint-hierarchy based way using VCL. Invoking the composition service triggers the composition process and upon success the newly composed service is immediately deployed and available. This solution requires no client-side composition infrastructure because it is transparently encapsulated in the CAAS infrastructure.

Abstract not found

Abstract. Domain-specific languages are constructed to provide modelling capabilities tailored to a specific domain. Sometimes, languages are developed many times, typically to support application in a new context. In doing so, recurring patterns and commonalities as well as variations across the evolving set of languages can be identified. This paper introduces the concept of a domain-specific metamodelling language, which codifies such commonalities and provides concepts and logic for expressing the variations. The challenges and difficulties of using domain-specific metamodelling languages are identified. We illustrate the concept with examples from different domains. 1

Programming languages are the primary mechanism by which software is created, yet most of us have access to only a few, fixed, programming languages. Any problem we wish to express must be framed in terms of the concepts the programming language provides for us, be they suitable for the problem or not. Domain Specific Languages (DSLs) suggest an appealing escape route from this fate, but since there is no real technology or theory underpinning them, new DSLs are rare. In this paper we present the Language Factories vision, which aims to bring together the theory and practice necessary to realise DSLs in a systematic way. In so doing, we hope to lower the barrier for language creation significantly, ultimately allowing software creators to use the languages most suited to them and their needs.

Abstract—This paper has been motivated by experience gained with specification and code generation of control elements for a software component platform and general-purpose (GP) programming language like Java and C. The problem to be addressed is two-fold: first, several domain-specific languages (DSL) are to be employed to express different element concerns (architecture, deployment context, code pattern) and second, porting to another GP language should avoid modification of the specification and related code generation process as much as possible. In both respects, the classical template-based code generation technique proved to be inflexible, requiring the code generator to be blurred with ad-hoc encoded DSL facets. The paper addresses the problem by introducing the concept of interoperable DSL family. Each member of the family is built around its core language which can be further specialized by embedding into a target programming language. Interoperability of these DSLs is achieved at the level of ASTs with help of queries. As a proof of the concept, we have implemented the queries via the AST transformation rules of the Stratego/XT framework. In the evaluation, we provide a comparison with the original template-based implementation which clearly indicates the DSL family and AST transformation benefits. We also provide examples of application areas where the concept of interoperable DSL family can be employed (and also indicate how this can be done). Keywords—Code Generation, domain specific languages, models reuse, extensible languages, specification, program synthesis. 1

year = {2008}, editor = {Daniel Schwabe and Francisco Curbera}, address = {Yorktown Heights, New York, USA}, month = {July}, publisher = {IEEE}, pubcat = {conference}, project = {MoDSE and ASSESS and WebDSL and Stratego}

Language for Web Applications},

Abstract The development of Web applications involves many stakeholders with different expertise. In many cases, the development of Web applications provides only technical models and their implementations, making it hard for non-technical stakeholders to get involved into the development process. As a result, a permanent collaboration and communication between all participating technical and non-technical stakeholders is needed during the whole development process. This paper proposes a model-driven approach of Domain-specific Modeling Languages (DSML) to separate the technical details from the non-technical ones. Non-technical stakeholders, also called domain experts, can assist the technical experts to map not well-known domain problems to the appropriate technological models. This leads to an intense collaboration between the different stakeholders and lowers the possibility of misunderstandings. These concepts improve the collaboration and, as a consequence, lowers the possibility of misunderstandings. Also, the modeldriven approach leads to a better maintainability and reusability of the resulting Web application. 1

The development process of web information systems is often tedious, error prone and usually involves redundant steps of work. Therefore, it is rather efficient to employ a modeldriven approach for the systematic aspects that comprise such a system. This involves models for the data structure that shall be handled by the system (here: class diagrams), various editable and read-only presentations (views) on combinations and extractions of the underlying data (here: a special view language) and ways to connect these views and define data flow between them (here: activity diagrams). In this paper, we present the MontiWeb approach to model and generate these aspects in a modular manner by incorperating the MontiCore framework. Therefor we shortly introduce the infrastructure that helps to develop modular systems. This involves the whole development process from defining the modeling languages to final code generation as well as all steps in between. We present the text-based class and activity diagram languages as well as a view language that are used to model our system. 1.

title = {Domain-Specific Languages for Composable Editor Plugins}, booktitle = {Proceedings of the Ninth Workshop on Language Descriptions, Tools, and Applications (LDTA 2009)}, year = {2009}, editor = {T. Ekman and J. Vinju},