I'm a Researcher in domain-specific languages and software variability.

Researcher

Pursuing the craft of simplifying programming, I'm researching how to build and utilize domain-specific languages. I'm also interested into metaprogramming and software paradigms, such as features, contexts, and aspects. The grand challenge is to identify how to manage software variability.

DSL – rbFeatures: Feature-Oriented Programmin in Ruby

Feature-Oriented Programming is a paradigm that addresses the configurability of your application. It helps you to modularize your source code according to its functional features. Features can be as coarse granular as complete modules or classes, or as fine granular as statements inside method bodies. rbFeatures is an extension to the Ruby programming language that enables Feature-oriented programming. With the simple expression Feature.code you can encompass any Ruby code – complete classes, methods, or individual source code lines – to mark what belongs to a feature. Then you just specify which features your program should activate, and you receive an appropriate customized program.

Software-as-a-Service (SaaS) applications are multi-tenant software applications that are delivered as highly configurable web services to individual customers, which are called tenants in this context. For reasons of complexity management and to lower maintenance cost, SaaS providers maintain and deploy a single version of the application code for all tenants. As a result, however, custom-made extensions for individual tenants cannot be efficiently integrated and managed. In this paper we show that by using a context-oriented programming model, cross-tier tenant-specific software variations can be easily integrated into the single-version application code base. Moreover, the selection of which variations to execute can be configured on a per tenant basis. Concretely, we provide a technical case study based on Google App Engine (GAE), a cloud platform for building multitenant web applications. We contribute by showing: (a) how ContextJ, a context-oriented programming (COP) language, can be used with GAE, (b) the increase in flexibility and customizability of tenant-specific software variations using ContextJ as compared to Google’s dependency injection framework Guice, and (c) that the performance of using ContextJ is comparable to Guice. Based on these observations, we come to the conclusion that COP can be helpful for providing software variations in SaaS.

A great part of software development challenges can be solved by one universal tool: Abstraction. Developers solve development challenges by using expressions and concepts that abstract from too technical details. One especially supportive tool for abstraction are domain-specific languages (DSLs). DSLs are specifically crafted languages that support abstraction in two ways. On the one side, they abstract from the (real-world) concepts of the domain by introducing objects with structure and behavior that are representative for the domain. On the other side, they abstract from a programming language and do not depend on hardware-specific details. We focus on internal DSLs, which are build on top of an existing host language. Such DSLs can completely use the development tools of their host, are quick to build because they reuse existing abstractions, and can be easily integrated with other programs, libraries, and DSLs of the same host.

This paper’s contribution is a set of six DSL design principles and a catalog of DSL design patterns. We differentiate into three types of patterns: Foundation patterns, which provide a DSL’s basic objects and operations, notation patterns, which provide the overall layout of the DSL and help to design individual expressions, and abstractions patterns, which help to implement the domain-specific abstractions. Each pattern identifies a development context, design goals that support the design principles, a general solution and a concrete example. To show the applicability of our research results, we document the pattern utilization in 12 other DSLs for the selected host languages Ruby, Python, and Scala. Finally we extend the patterns towards a pattern language by detailing the relationships between the patterns and by showing how other patterns can be incorporated with our patterns.

Software variability can be supported by providing adaptations on top of a program's core behavior. For defining and composing adaptations in a program, different paradigms have been proposed. Two of them are feature-oriented programming and context-oriented programming. This paper compares an exemplar implementation of each paradigm. For the comparison, a common case study is used in which we detail how adaptations are defined, expressed, and composed in each paradigm. Based on the case study, we uncover similarities and differences of each implementation, and derive a set of characteristics that identify each of them. The experiment shows several overlapping similarities between the two implementations, which is an indicator that there is a similar core set of characteristics for each paradigm. This finding brings the two seemingly disjoint research directions together, and can stimulate future research both in the direction of merging features and context as well as to improve the characteristic strengths of each paradigm.

Domain-Specific Languages (DSL) abstract from the domain entities and operations to represent domain knowledge in the form of an executable language. While they solve many of the current software development challenges, related literature claims that DSLs usually have a flaw: The high effort required to implement and use them. However, internal DSLs are developed with less effort because they are built on top of an existing programming language and can use the whole language infrastructure consisting of interpreter, compiler, or editors. This article presents an engineering process for internal DSLs. An agile process leads from analysis to design and implementation. Expressions and language capabilities are implemented using tests and a set of patterns, which provide reusable knowledge how to properly structure and design the DSL implementation. As a case study, we show how to implement a software product line configuration DSL using Ruby and Python as host languages. In summary, the proposed process and patterns facilitate the successful planning and developing of internal DSLs using dynamic programming languages as the host.

Workshop Paper – PyQL: Introducing a SQL-like DSL for Python

This paper explores Python's capabilities to implement SQL-like expressions as an internal Domain-Specific Language. We design the language throughout the phases domain analysis, language design, and language implementation. We explain how the different requirements of the DSL are satisfied by using Python's language constructs and metaprogramming capabilities. By exploring these capabilities, the article provides insides into how domain-specific abstractions can be implemented in Python.

Journal Paper – rbFeatures: Feature-Oriented Programming with Ruby

Features are pieces of core functionality of a program that is relevant to particular stakeholders. Features pose dependencies and constraints among each other. These dependencies and constraints describe the possible number of variants of the program: A valid feature configuration generates a specific variant with unique behavior. Feature-Oriented Programming is used to implement features as program units. This paper introduces rbFeatures, an feature-oriented programming language implemented on top of the dynamic programming language Ruby. With rbFeatures, programmers use software product lines, variants, and features as first-class entities. This allows several runtime reflection and modification capabilities, including the extension of the product line with new features and the provision of multiple variants. The paper gives a broad overview to the implementation and application of rbFeatures. We explain how features as first-class entities are designed and implemented, and discuss how the semantics of features are carefully added to Ruby programs. We show two case studies: The expression product line, a common example in feature-oriented programming, and a web application.

About Me

I'm a Researcher in domain-specific languages and language design, a Programmer of web applications and mobile applications, and passionate about Productivity. I love to help other people in Empowering themselves, and I'm a frequent Athlete and a dedicated Reader of fantasy and non-fiction books.