Abstract. System family engineering seeks to exploit the commonalities among systems from a given problem domain while managing the variabilities among them in a systematic way. In system family engineering, new system variants can be rapidly created based on a set of reusable assets (such as a common architecture, components, models, etc.). Generative software development aims at modeling and implementing system families in such a way that a given system can be automatically generated from a specification written in one or more textual or graphical domainspecific languages. This paper gives an overview of the basic concepts and ideas of generative software development including DSLs, domain and application engineering, generative domain models, networks of domains, and technology projections. The paper also discusses the relationship of generative software development to other emerging areas such as Model Driven Development and Aspect-Oriented Software Development. 1

The influential pure embedding methodology of embedding domainspecific languages (DSLs) as libraries into a general-purpose host language forces the DSL designer to commit to a single semantics. This precludes the subsequent addition of compilation, optimization or domain-specific analyses. We propose polymorphic embedding of DSLs, where many different interpretations of a DSL can be provided as reusable components, and show how polymorphic embedding can be realized in the programming language Scala. With polymorphic embedding, the static type-safety, modularity, composability and rapid prototyping of pure embedding are reconciled with the flexibility attainable by external toolchains. Categories and Subject Descriptors D.3.2 [Programming Languages]: Language Classifications—Extensible languages, Specialized

I present ZyTyG, a strategy to define domain-specific languages with a user-friendly syntax. This strategy does not requires any pre-processor or metaprogramming facility and only relies on features provided by the object-oriented host language. I describe its application to ScalaDBC, a database library with an embedded DSL to encode queries in SQL-like syntax and that uses this strategy. 1

We propose a combination of partial evaluation and staged interpretation with MetaOCaml for rapid prototyping of domain-specific languages. Interpretation is an easy way to implement such languages. MetaOCaml can eliminate the overhead of interpretation at run time, if the interpreter is written in a staged form, i.e., takes the source program separate from the input data in a first stage. Partial evaluation of the source program with values known at compile time can further improve the target code performance. Additional aggressive optimizations are possible due to the absence of general recursion. Algebraic simplifications can even achieve binding-time improvements during the online partial evaluation. Our approach both saves the application programmer completely from binding-time considerations and exploits staged interpretation with MetaOCaml for target code generation. The example domain presented in this paper is image processing, in which the domain-specific language permits the specification of convolution matrices, summations, case distinctions and non-local pixel accesses. All expressions known at compile time are simplified and all remaining expressions are turned into MetaO-Caml code parts, which are combined to form the compiled application program. The example specifications deal with filtering by convolution and iterations in a series of images for wave effects and temperature distribution. The experimental results show significant speedups if online partial evaluation with algebraic simplifications is used for elimination of interpretation overhead and optimization of code expressions. Key words: binding-time improvement, compilation, domain-specific languages, meta-programming, partial evaluation, staged interpretation

Implementation of a Skeleton-Based Parallel

This article presents an in-depth study of the close connection between Haskell type classes and C++ template/traits mechanism- two different facilties for implementing generic programming concepts. Haskell type classes and various extensions can be closely mimicked by C++ templates/traits and related mechanisms. We highlight the subtleties related to type-based computations and the limitations induced by language design on the program behaviour by a number of examples. 1

With the emergence of model driven engineering (MDE), the creation of domain specific languages (DSL) is becoming a fundamental part of language engineering. The development cost of a DSL should be modest, compared to the cost of developing a general-purpose programming language. Reducing the implementation effort and providing reuse techniques are key aspects for DSL approaches to be really effective. In this paper we present an approach to build embedded domain specific languages applying the principles of model driven engineering. On the basis of this approach we will tackle reuse of DSLs by defining families of DSLs, addressing reuse both from the DSL developer and user point of views. A family of DSLs will be built up by composing several DSLs, so we will propose composition mechanisms for the abstract syntax, concrete syntax and model transformation levels of a DSL's definition. Finally, we contribute a software framework to support our approach, and we illustrate the paper with a case study to demonstrate its practical applicability.

Abstract—Recently, there has been a growing interest in what have come to be known as domain-specific languages (DSLs). This paper introduces a definition for DSLs, explains how DSLs can have a far-reaching impact on our lives, and discusses why DSLs are here to stay.

Abstract not found

In the modern, multi-threaded, multi-core programming environment, correctly managing system resources such as locks and shared variables can be especially difficult and error-prone. A simple error, such as forgetting to release a lock, can have major consequences on the correct operation of the program (e.g. deadlock), often at a time and location that is isolated from the original error. While there have been many previous proposals for managing locks and resources, these often arise from the systems arena, and are therefore often only loosely integrated with the host programming language. Such approaches therefore do not generally provide the strong formal guarantees of correctness-by-construction that we would prefer for all fundamental properties of our programs. In this paper, we propose a new type-based approach to resource management, based on the use of dependent types to construct a Domain-Specific Embedded Language (DSEL) whose typing rules enforce the properties we require. We illustrate our approach by implementing a DSEL for concurrent programming and demonstrate its applicability with reference to concurrent transactions on a bank account. 1.