Software and programming have a brilliant past that has brought us the automation of many expected and unexpected human and societal activities ranging from banking and consumer electronics to mobile networking, search engines and social networks. The present of software is overwhelming: many software systems have sizes in the range of 10–100 million lines of source code and contain tens of thousands of errors that are yet to be discovered. We claim that software will only have a big future if software itself becomes smaller. Smaller software leads to higher software productivity (we have to write less) and higher software quality (quality guarantees become part of the language and not of the program). But how can we reduce the size of programs by two or three orders of magnitude?
A domain-specific language (DSL) is a dedicated language to solve problems in a clearly delineated domain. By using a DSL, programs can be written in high-level domain concepts rather than in low- level implementation concepts. The execution of DSL programs (by interpretation, compilation, simulation or other means) can also use domain knowledge to perform high-level checks, to optimize, and to provide guarantees. Size reductions (and corresponding productivity gains) with a factor 10–50 have been observed on real projects using DSLs.
Our hypothesis is that DSLs are a very promising solution direction for raising both software productivity and software quality and that they should become an integral part of the software creation process. However, both the design and the implementation of DSLs provide conceptual, scientific and technical challenges that have to be solved before this can become reality. We will address DSL design by performing software analysis and fact extraction on software in the same domain that predates the DSL. Automatically extracted feature and concept diagrams will enable the human designer to quickstart his design activity. We will explore which concepts and tools are needed to provide the designer with a knowledge-intensive, interactive, design environment. The implementation of DSLs will be based on meta-programming, an approach where programs use other programs as data and may read, manipulate or write other programs. Known shortcomings of meta-programming will be addressed such as syntactic expressivity, compositionality and scaleability. Case studies in forensics, accountancy and meta-programming will be used for inspiration and validation of the project.
We pose the challenge to create a completely self-hosting DSL development environment in less than 25.000 lines of code. Like the mythical Phoenix, such an environment can reproduce itself.
Key publications
- Paul Klint, Tijs van der Storm, Jurgen Vinju, Rascal: a Domain Specific Language for Source Code Analysis and Manipulation, in: Proceedings of Proceedings of 9th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM'09), IEEE, 2009
- Paul Klint, Tijs van der Storm and Jurgen Vinju, On the Impact of DSL Tools on the Maintainability of Language Implementations, in: Proceedings of the 10th Workshop on Language Descriptions, Tools and Applications (LDTA'10), ACM, 2010.
- Arie van Deursen, Paul Klint and Joost Visser, Domain-specific Languages, in Allen Kent and James G. Williams (eds.), Encyclopedia of Microprocessors, Volume 28, 53-68, Marcel Dekker, Inc. New York, 2002.
- Arie van Deursen and Paul Klint, Little Languages: Little Maintenance? In Journal of Software Maintenance 1998, 10: 75-92.
Members
- Prof. Dr. Paul Klint (project leader)
- Dr. Jurgen Vinju
- Dr. Tijs van der Storm
- Dr. Mark Hills
- Drs. Anastasia Izmaylova (PhD student)
- Drs. Davy Landman (PhD student)
