Abstract. The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This requires technology for designing and implementing DSLs, but also a methodology for using that technology. That is, a collection of guidelines, design patterns, and reusable DSL components that show developers how

Tool support for refactoring code written in mainstream languages such as C and C is currently lacking due to the complexity introduced by the mandatory preprocessing phase that forms part of the C/C compilation cycle. The defintion and use of macros complicates the notions of scope and of identifier boundaries. The concept of token equivalence classes can be used to bridge the gap between the language proper semantic analysis and the nonpreprocessed source code. The CScout toolchest uses the developed theory to analyze large interdependent program families. A Web-based interactive front end allows the precise realization of rename and remove refactorings on the original C source code. In addition, CScout can convert programs into a portable obfuscated format or store a complete and accurate representation of the code and its identifiers in a relational database.

The Information Furnace is a basement-installed PC-type device that integrates existing consumer home-control, infotainment, security, and communication technologies to transparently provide accessible and value-added services. A modern home contains a large number of sophisticated devices and technologies. Access to these devices is currently provided through a wide variety of disparate interfaces.

Abstract. Domain-specific languages (DSLs) are increasingly used as embedded languages within general-purpose host languages. DSLs provide a compact, dedicated syntax for specifying parts of an application related to specialized domains. Unfortunately, such language extensions typically do not integrate well with the development tools of the host language. Editors, compilers and debuggers are either unaware of the extensions, or must be adapted at a non-trivial cost. We present a novel approach to embed DSLs into an existing host language by leveraging the underlying representation of the host language used by these tools. Helvetia is an extensible system that intercepts the compilation pipeline of the Smalltalk host language to seamlessly integrate language extensions. We validate our approach by case studies that demonstrate three fundamentally different ways to extend or adapt the host language syntax and semantics. 1

A key advantage for the use of a Domain-Specific Language (DSL) is the leverage that can be captured from a concise representation of a programmer's intention. This paper reports on three different DSLs that were developed for two different projects. Two of the DSLs assisted in the specification of various modeling tool ontologies, and the integration of models across these tools. On another project, a different DSL has been applied as a language to assist in aspect-oriented modeling. Each of these three languages was converted to C++ using different code generators. These DSLs were concerned with issues of traversing a model and performing transformations. The paper also provides quantitative data on the relative sizes of the intention (as expressed in the DSL) and the generated C++ code. Observations are made regarding the nature of the benefits and the manner in which the conciseness of the DSL is best leveraged.

INTRODUCTION Morphogenesis governs the clustering of biological cells into shapes and patterns during early embryonic development [Keeton 1972]. During morphogenesis, cells interact involving both secreted and membrane-bound chemicals, generating biologically significant patterning instabilities. Some of these instabilities can be described by mathematical models [Glazier and Graner 1993], [Graner and Glazier 1992], [Hentschel et al. 2004], [Jiang et al. 1998], [Kiskowski et al. 2004], [Meinhardt 1982], [Newman and Frisch 1979], [Zeng et al. Author's address: J. Izaguirre, Department of Computer Science and Engineering, University of Notre Dame, 384 Fitzpatrick Hall of Engineering, Notre Dame, IN 46556. Support for this research was provided by an Arthur J. Schmitt Fellowship. Permission to make digital/hard copy of all or part of this material without fee for personal or classroom use provided that the co

Domain-specific languages (DSL) receive a constantly growing attention in the area of software development. However, so far the documentation of reusable architectural knowledge for DSL design is rather limited. In this paper, we systematically explore the DSL design space by combining reusable architectural decision modeling and software patterns. In particular, we have explored three reusable architectural decisions in this design space: the decision for the type of DSL development process, the decision for the concrete syntax style, and the decision for developing an external vs. an embedded DSL. These decisions are foundational for each DSL project. Each of these decisions has a number of (candidate) patterns for DSL design. These (candidate) patterns define alternative solutions in the shared context and problem space of the respective reusable architectural decision. 1

Domain-specific languages (DSLs) assist a software developer (or end-user) in writing a program using idioms that are similar to the abstractions found in a specific problem domain. Testing tool support for DSLs is lacking when compared to the capabilities provided for standard general-purpose languages (GPLs), such as Java and C++. For example, support for debugging and unit testing a program written in a DSL is often non-existent. The lack of a debugger and unit test engine at the proper abstraction level limits an end-user‟s ability to discover and locate faults in a DSL program. This dissertation describes a grammar-driven technique to build a debugging and unit testing tool generation framework by adaptations to existing DSL grammars. This approach leverages existing GPL testing tools to indirectly exercise the end-user‟s debug and test intentions at the DSL level. The adaptations to DSL grammars represent the hooks needed to interface with a supporting infrastructure constructed for an Integrated Development Environment (IDE) that assists in debugging and unit testing a program written in a DSL. The contribution represents a coordinated approach to bring essential

Abstract. As domain-specific modeling begins to attract widespread acceptance, pressure is increasing for the development of new domainspecific languages. Unfortunately these DSLs typically conflict with the grammar of the host language, making it difficult to compose hybrid code except at the level of strings; few mechanisms (if any) exist to control the scope of usage of multiple DSLs; and, most seriously, existing host language tools are typically unaware of the DSL extensions, thus hampering the development process. Language boxes address these issues by offering a simple, modular mechanism to encapsulate (i) compositional changes to the host language, (ii) transformations to address various concerns such as compilation and syntax highlighting, and (iii) scoping rules to control visibility of fine-grained language extensions. We describe the design and implementation of language boxes, and show with the help of several examples how modular extensions can be introduced to a host language and environment. 1

The Information Furnace is a basement-installed PC-type device that integrates existing consumer home-control, infotainment, security, and communication technologies to transparently provide user-friendly access and value-added services.