Introduction
About me
I am a researcher in the Software Analysis and Transformation Group
at the Dutch research institute Centrum
Wiskunde & Informatica (CWI). I am working on software
analysis and transformation, in particular in the domain of Domain
Specific Languages and Model-Driven Engineering. Together
with Paul Klint
and Jurgen Vinju I am one of
the designers
of Rascal,
a domain specific language for meta programming. I am also working
together with William
Cook on a model-driven programming framework,
called Ensō. You can find my
CV here.
I'm also co-organizing the first Dutch Conference on Software Development Automation (SDA'13), which will be hosted at CWI on 29th of May 2013. The program of this (industrial) conference is focused around how model-driven development (MDD) is applied in industry, what are its successfactors, and what tools are available to realize MDD.
One day in the week I am involved in teaching courses on software
evolution and construction in
the Master
Software Engineering at the University of Amsterdam (UvA).
Contact information
Click here to add to your contacts.
Publications
2013
-
Jeroen van den Bos, Tijs van der Storm, A Case Study in Evidence-Based DSL Evolution, in: Proceedings of the European Conference on Modelling Foundations and Applications (ECMFA'13), 2013.
[pdf]
[abstract].
Abstract: Domain-specific languages (DSLs) can
significantly increase productivity and quality in software
construction. However, even DSL programs need to evolve to accomodate
changing requirements and circumstances. How can we know if the design
of a DSL supports the relevant evolution scenarios on its programs?
We present an experimental approach to evaluate the evolutionary
capabilities of a DSL and apply it on a DSL for digital forensics,
called Derric. Our results indicate that the majority of required
changes to Derric programs are easily expressed. However, some
scenarios suggest that the DSL design can be improved to prevent
future maintenance problems. Our experimental approach can be
considered first steps towards evidence-based DSL evolution.
-
Bruno C. d. S. Oliveira, Tijs van der Storm, Alex Loh and William R. Cook, Feature-Oriented Programming with Object Algebras, in: Proceedings of the 27th European Conference on Object-Oriented Programming (ECOOP'13), 2013.
[pdf]
[code]
[abstract].
Abstract:
Object algebras are a new programming technique that enables a simple
solution to basic extensibility and modularity issues in programming
languages. While object algebras excel at defining modular features,
the composition mechanisms for object algebras (and features) are
still cumbersome and limited in expressiveness. In this paper we
leverage two well-studied type system features, intersection types and
type-constructor polymorphism, to provide object algebras with
expressive and practical composition mechanisms. Intersection types
are used for defining expressive run-time composition operators
(combinators) that produce objects with multiple (feature)
interfaces. Type-constructor polymorphism enables generic interfaces
for the various object algebra combinators. Such generic interfaces
can be used as a type-safe front end for a generic implementation of
the combinators based on reflection. Additionally, we also provide a
modular mechanism to allow different forms of self-references in the
presence of delegation-based combinators. The result is an expressive,
type-safe, dynamic, delegation-based composition technique for object
algebras, implemented in Scala, which effectively enables a form of
Feature-Oriented Programming using object algebras.
-
Tijs van der Storm, Semantic Deltas for Live DSL Environments, in: Proceedings of the 1st International Workshop on Live Programming (LIVE'13), 2013 (to appear).
[pdf]
[abstract].
Abstract:
Domain-specific languages (DSLs) require IDE support, just like
ordinary programming languages. This paper introduces semantic deltas
as a foundation for building live DSL environments to bridge the "gulf
of evaluation" between DSL code and the running application. Semantic
deltas are distinguished from textual or structural deltas in two
ways. First, they have meaning in the application domain captured by
the DSL. Second, they can be interpreted at runtime so that the
behavior of the running system adapts to the evolved DSL
code. Semantic deltas have the potential to support back-in-time
debugging, application state persistence, version control, retroactive
updates and exploring what-if scenarios. I present early experiences
in building a live DSL environment and identify areas for future
research.
2012
-
Tijs van der Storm,
William R. Cook and Alex Loh. Object Grammars: Compositional
& Bidirectional Mapping Between Text and Graphs (Ensō Paper 2 of 6), in: Proceedings of the 5th International Conference on Software Language Engineering (SLE'12), 2012. [pdf] [slides]
[abstract].
Abstract:
Object Grammars define mappings between text and object graphs.
Parsing recognizes syntactic features and creates the
corresponding object structure. In the reverse
direction, formatting recognizes object graph features and
generates an appropriate textual presentation. The key to Object
Grammars is the expressive power of the mapping, which decouples the
syntactic structure from the graph structure. To handle graphs, Object
Grammars support declarative annotations for resolving textual names
that refer to arbitrary objects in the graph structure. Predicates on
the semantic structure provide additional control over the
mapping. Furthermore, Object Grammars are compositional so that
languages may be defined in a modular fashion. We have implemented our
approach to Object Grammars as one of the foundations of the Ensō
system and illustrate the utility of our approach by showing how it
enables definition and composition of domain-specific languages
(DSLs).
-
Alex Loh, Tijs van der Storm, and
William R. Cook. Managed Data: Modular Strategies for Data
Abstraction (Ensō Paper 1 of 6), in: Onward! Research Track at SPLASH'12, 2012. [pdf]
[abstract].
Abstract: Managed Data is a two-level approach
to data abstraction in which programmers first define data description
and manipulation mechanisms, and then use these mechanisms to define
specific kinds of data. Managed Data allows programmers to take
control of many important aspects of data, including persistence,
access/change control, reactivity, logging, bidirectional
relationships, resource management, invariants and validation. These
strategies for implementing these features are implemented once as
reusable modules. Managed Data is a general concept that can be
implemented in many ways, including reflection, metaclasses, and
macros. In this paper we argue for the importance of Managed Data and
present a novel implementation of Managed Data based on interpretation
of data models. The paper also discusses strategies for implementing
Managed Data. In object-oriented languages, Managed Data typically
requires programmer control over the meaning of the field/method
access operator (the "dot" operator). Bootstrapping poses
difficulties, because implementing the first data manager requires
some data. As a case study, we used Managed Data in a web development
framework from the Ensō project to reuse database management and
access control mechanisms across different data definitions.
- Jeroen van den Bos and Tijs van der Storm, Domain-Specific Languages for Better Forensic Software, in: ERCIM News 2012(90).
[link]
- Jeroen van den Bos and Tijs van der Storm,
Domain-Specific Optimization in Digital Forensics,
in: Proceedings of the 5th International Conference on Model Transformation (ICMT'12), 2012.
[pdf]
[bib]
[abstract].
Abstract: File carvers are forensic software
tools used to recover data from storage devices in order to find
evidence. Every legal case requires different trade-offs between
precision and runtime performance. The resulting required changes to
the software tools are performed manually and under the strictest
deadlines.
In this paper we present a model-driven approach to file carver
development that enables these trade-offs to be automated. By
transforming high-level file format specifications into
approximations that are more permissive, forensic investigators can
trade precision for performance, without having to change source.
Our study shows that performance gains up to a factor of 3 can be
achieved, at the expense of up to 8% in precision and 5% in recall.
2011
-
Jeroen van den Bos, Mark Hills, Paul Klint, Tijs van der Storm and
Jurgen J. Vinju, Rascal: From Algebraic Specification to Meta-Programming,
in: Proceedings of the 2nd Workshop on Algebraic Methods in
Model-Based Software Engineering (AMMSE'11), 2011.
[arxiv]
[pdf]
[bib]
[abstract].
Abstract:Algebraic specification has a long
tradition in bridging the gap between specification and programming
by making specifications executable. Building on extensive experience
in designing, implementing and using specification formalisms that
are based on algebraic specification and term rewriting (namely ASF
and ASF+SDF), we are now focusing on using the best concepts from
algebraic specification and integrating these into a new programming
language: RASCAL. This language is easy to learn by non-experts but is
also scalable to very large meta-programming applications. We explain
the algebraic roots of RASCAL and its main application areas: software
analysis, software transformation, and design and implementation of
domain-specific languages. Some example applications in the domain of
Model-Driven Engineering (MDE) are described to illustrate this.
- Mark Hills, Paul Klint, Jurgen J. Vinju, Tijs van der
Storm, A Case of Visitor versus Interpreter
Pattern, in: Proceedings of the 49th International
Conference on Objects, Models, Components and Patterns
(TOOLS'11), 2011.
[pdf]
[bib]
[abstract].
Abstract: We compare the Visitor pattern with the
Interpreter pattern, investigating a single case in point for the Java
language. We have produced and compared two versions of an interpreter
for a programming language. The first version makes use of the Visitor
pattern. The second version was obtained by using an automated
refactoring to transform uses of the Visitor pattern to uses of the
Interpreter pattern. We compare these two nearly equivalent versions
on their maintenance characteristics and execution efficiency. Using
a tailored experimental research method we can highlight differences
and the causes thereof. The contributions of this paper are that it
isolates the choice between Visitor and Interpreter in a realistic
software project and makes the difference experimentally observable.
- Jeroen van den Bos and Tijs van der Storm,
Bringing Domain-Specific Languages to Digital Forensics, in:
Proceedings of the 33rd International Conference on Software
Engineering (ICSE'11), Software Engineering in Practice,
ACM, 2011.
[pdf]
[bib]
[abstract].
Abstract:
Digital forensics investigations often consist of analyzing large
quantities of data. The software tools used for analyzing such data
are constantly evolved to cope with a multiplicity of versions and
variants of data formats. This process of customization is time
consuming and error prone.
To improve this situation we present Derric, a domain-specific
language (DSL) for declaratively specifying data structures. This
way, the specification of structure is separated from data
processing. The resulting architecture encourages customization and
facilitates reuse. It enables faster development through a division
of labour between investigators and software engineers.
We have performed an initial evaluation of Derric by constructing
a data recovery tool. This so-called carver has been
automatically derived from a declarative description of the
structure of JPEG files. We compare it to existing carvers, and show
it to be in the same league both with respect to recovered evidence,
and runtime performance.
- Tijs van der Storm, The Rascal Language
Workbench, in: Language Workbench Competition 2011
(LWC'11), CWI Technical Report SEN-1111,
2011. [pdf] [bib] [CWI]
2010
- Vincent Lussenburg, Tijs van der Storm, Jurgen Vinju and Jos Warmer,
Mod4J: A Qualitative Case Study of Model-Driven Software Development, in:
Proceedings of the 13th International Conference on Model Driven Engineering Languages and Systems (MoDELS'10), ACM/IEEE, 2010.
[pdf]
[bib]
[abstract].
Abstract:
Model-driven software development (MDSD) has been on the rise over
the past few years and is becoming more and more mature. However,
evaluation in real-life industrial context is still scarce.
In this paper, we present a case-study evaluating the applicability
of a state-of-the-art MDSD tool, Mod4J, a suite of domain specific
languages (DSLs) for developing administrative enterprise
applications. Mod4J was used to partially rebuild an industrially
representative application. This implementation was then compared to
a base implementation based on elicited success criteria. Our
evaluation leads to a number of recommendations to improve Mod4J.
We conclude that having extension points for hand-written code is a
good feature for a model driven software development environment.
- Tijs van der Storm, Token Interception for Syntax
Embedding. Unpublished draft. 2010.
[pdf]
[abstract].
Abstract: Syntax embedding is an attractive
implementation pattern for the development of domain-specific
languages (DSLs). However, parsing a source text containing different
embedded DSL fragments currently requires complicated techniques and
tools. In this paper I present token interception as a simple and
elegant implementation pattern for implementing syntax embedding. The
resulting architecture supports general, multi-level and dynamic
embeddings of syntax. The pattern is used in the implementation of
context-free syntax embeddings in Clojure.
- Bas Basten, Tijs van der Storm,
AmbiDexter: Practical Ambiguity Detection (tool demonstration), in:
Proceedings of the Tenth IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM'10), IEEE, 2010.
[pdf]
[bib]
[abstract].
Abstract: Ambiguity detection tools try to
statically track down ambiguities in context-free grammars. Current
ambiguity detection tools, however, either are too slow for large
real- istic cases, or produce incomprehensible ambiguity
reports. AmbiDexter is
the ambiguity tool to have your cake and eat it too.
- 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.
[pdf]
[bib]
[abstract].
Abstract:
Does the use of DSL tools improve the maintainability of language
implementations compared to implementations from scratch? We present
empirical results on aspects of maintainability of six implementations of
the same DSL using different languages (Java, JavaScript, C#) and
DSL tools (ANTLR, OMeta, Microsoft Oslo). Our evaluation indicates
that the maintainability of language implementations is indeed
higher when constructed using DSL tools.
- Tijs van der Storm,
Relational Meta-Modeling, in:
Relationships, Objects, Roles, and Queries in Modern Programming
Languages, Abstract. Dagstuhl Seminar Proceedings 10152, 2010.
[abstract].
Abstract: We propose relations as a concept to
reduce the impedance mismatch between object-oriented models and
algebraic data types in the context of model-driven engineering
(MDE). Initial experiments show that certain types of model analysis
and model transformation can be expressed in a very natural way if OO
models are encoded relationally.
2009
- Thiago Tonelli Bartolomei, Krzysztof Czarnecki, Ralf Lämmel and Tijs van der Storm
Study of an API migration for two XML APIs, in: Proceedings of the 2nd International Conference on Software Language Engineering (SLE 2009), Springer, 2009.
[pdf]
[web]
[implementation].
[abstract].
Abstract: API migration refers to adapting an
application such that its dependence on a given API (the source API)
is eliminated in favor of depending on an alternative API (the target
API) with the source and target APIs serving the same domain. One may
attempt to automate API migration by code transformation or wrapping
of some sort. API migration is relatively well understood for the
special case where source and target APIs are essentially different
versions of the same API. API migration is much less understood for
the general case where the two APIs have been developed more or less
independently of each other. The present paper exercises a simple
instance of the general case and develops engineering techniques
towards the mastery of API migration. That is, we study wrapper-based
migration between two prominent XML APIs for the Java platform. The
migration follows an iterative and test-driven approach and allows us
to identify, classify, and measure various differences between the
studied APIs in a systematic way.
- Ralf Lämmel and Tijs van der Storm, Crossing the
Rubicon of API Migration, Unpublished Draft, 2009.
[pdf]
[web]
[abstract].
Abstract: Within the programming domain of XML
processing, we set up a benchmark for API migration. The benchmark is
a suite of XML processing scenarios that are implemented in terms of
different XML APIs. We suggest that a relatively general technique for
API migration should be capable of providing source-to-source
translations between the different implementations. The benchmark
involves APIs that are different enough to require more than just
local rewrites for the migration. We make different attempts at API
migration: wrapping, rewriting, and protocol-based translation. None
of our attempts are entirely satisfactory, and we hope to provide this
benchmark as a challenge to the broader programming language and
automated software engineering communities.
- Tijs van der Storm, Towards Dynamically Extensible
Syntax, in: Discus Amicorum Jan Heering, CWI,
2009. [pdf]
[abstract].
Abstract:
Domain specific language embedding requires either a very flexible
host language to approximate the desired level of abstraction, – or
elaborate tool support for "compiling away" embedded notation. The
former confines the language designer to reinterpreting a given
syntax. The latter prohibits runtime analysis, interpretation and
transformation of the embedded language. I tentatively present
CherryLisp: a Lisp dialect with dynamically user-definable syntax that
suffers from neither of these drawbacks.
- Paul Klint, Tijs van der Storm, Jurgen Vinju, EASY
Meta-Programming with Rascal. Leveraging the
Extract-Analyze-SYnthesize Paradigm for
Meta-Programming, in: Proceedings of the 3rd International Summer School on Generative and
Transformational Techniques in Software Engineering
(GTTSE'09), Springer LNCS 2009.
- 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.
[pdf] [bib]
[abstract].
Abstract: Many automated software engineering
tools require tight integration of techniques for source code analysis
and manipulation. State-of-the-art tools exist for both, but the
domains have remained notoriously separate because different
computational paradigms fit each domain best. This impedance mismatch
hampers the development of new solutions because the desired
functionality and scalability can only be achieved by repeated and ad
hoc integration of different techniques.
Rascal is a domain-specific language that takes away most of this
boilerplate by integrating source code analysis and manipulation at
the conceptual, syntactic, semantic and technical level. We give an
overview of the language and assess its merits by implementing a
complex refactoring.
2008
- Tijs van der Storm, Backtracking Incremental Continuous
Integration, in: Kostas Kontogiannis, Christos Tjortjis,
Andreas Winter, editors, Proceedings of the 12th
European Conference on Software Maintenance and Reengineering (CSMR'08),
IEEE, 2008.
[pdf] [bib]
[abstract].
Abstract:
Failing integration builds are show stoppers. Development activity is
stalled because developers have to wait with integrating new changes
until the problem is fixed and a successful build has been run. We
show how backtracking can be used to mitigate the impact of build failures
in the context of component-based software development. This way, even
in the face of failure, development may continue and a working version
is always available.
- Tijs van der Storm and Jurgen
Vinju. Using
the Meta-Environment for Domain Specific Language
Engineering, CWI Technical Report SEN-R0805, 2008.
2007
- Tijs van der Storm, Binary Change Set
Composition, in: H. W. Schmidt, I. Crnkovic,
G. T. Heineman, J. A. Stafford, editors, Proceedings of the
10th International ACM SIGSOFT Symposium on
Component-Based Software Engineering (CBSE'07), volume 4608 of LNCS,
pp. 17-32, Springer, 2007.
[pdf] [bib]
[abstract].
Abstract:
Binary component-based software updates that are lightweight,
efficient, safe and generic still remain a challenge. Most existing
deployment systems that achieve this goal have to control the complete
software environment of the user which is a barrier to adoption for
both software consumers and producers. Binary change set composition
is a technique to deliver incremental, binary updates for
component-based software systems in an efficient and non-intrusive
way. This way application updates can be delivered more frequently,
with minimal additional overhead for users and without sacrificing the
benefits of component-based software development.
- Tijs van der Storm, Generic Feature-Based
Composition, in: M. Lumpe and W. Vandeperren, editors,
Proceedings of the Workshop on Software Composition
(SC'07), volume 4829 of LNCS, pp. 66-80, Springer, 2007.
[pdf] [bib]
[abstract].
Abstract:
Bridging problem domain and solution in product line engineering is a
time-consuming and error-prone process.
Since both domains are structured differently (features
vs. artifacts), there is no natural way to map one to the other.
Using an explicit and formal mapping creates opportunities for
consistency checking and automation.
This way both the configuration and the composition of product
instances can be more robust, support more product variants and
be performed more often.
- Tijs van der Storm, The Sisyphus Continuous Integration System, in:
Proceedings of the Conference on Software Maintenance and Reengineering (CSMR'07 Tool Track), 2007.
[pdf] [bib]
[abstract].
Abstract: Integration hell is a prime example of
software evolution gone out of control. The Sisyphus continuous
integration system is designed to prevent this situation in the
context of component-based software configuration management. We show
how incremental and backtracking techniques are applied to strike a
balance between maximal feedback and being up-to-the-minute, and how
these techniques enable automation of release and delivery.
- M.G.J. van den Brand, M. Bruntink, G.R. Economopoulos, H.A. de Jong, P. Klint, T. Kooiker, T. van der Storm and J.J. Vinju,
Using The Meta-Environment for Maintenance and Renovation, in:
Proceedings of the Conference on Software Maintenance and Reengineering (CSMR'07 Tool Track), 2007.
[pdf] [bib]
[abstract].
2005
- Paul Klint, Tijs van der Storm, Jurgen Vinju, Term
Rewriting Meets Aspect Oriented Programming, in:
Processes, Terms and Cycles: Steps on the Road to Infinity, Essays
Dedicated to Jan Willem Klop, on the Occasion of His 60th Birthday, 2005, Springer, LNCS 3838, [springer link], [bib] [abstract].
Abstract: We explore the connection between term rewriting systems (TRS) and
aspect-oriented programming (AOP). Term rewriting is a paradigm that
is used in fields such as program transformation and theorem proving.
AOP is a method for decomposing software, complementary to the usual
separation into programs, classes, functions, etc. An aspect
represents code that is scattered across the components of an
otherwise orderly decomposed system. Using AOP, such code can be
modularized into aspects and then automatically weaved into a system.
Aspect weavers are available for only a handful of languages. Term
rewriting can offer a method for the rapid prototyping of weavers for
more languages. We explore this claim by presenting a simple weaver
implemented as a TRS.
We also observe that TRS can benefit from AOP. For example, their
flexibility can be enhanced by factoring out hardwired code for
tracing and logging rewrite rules. We explore methods for enhancing
TRS with aspects and present one application: automatically connecting
an interactive debugger to a language specification.
- Tijs van der Storm, Continuous Release and Upgrade of
Component-Based Software, in: Proceedings of the 12th
International Workshop on Software Configuration Management
(SCM-12), Lisbon, 2005, [pdf] [bib], [proceedings] [abstract].
Abstract:We show how under certain assumptions, the
release and delivery of software updates can be automated in the
context of component-based systems. These updates allow features or
fixes to be delivered to users more quickly. Furthermore, user
feedback is more accurate, thus enabling quicker response to defects
encountered in the field.
Based on a formal product model we extend the process of continuous
integration to enable the agile and automatic release of software
components component. From such releases traceable and incremental
updates are derived.
We have validated our solution with a prototype tool that computes and
delivers updates for a component-based software system developed at
CWI.
2004
- Tijs van der Storm, Variability and
Component Composition, in: Proceedings of the 8th International
Conference on Software Reuse (ICSR-8), 2004, [pdf] [bib] [abstract].
Abstract: In component-based product populations, variability has to be
described at the component level to be able to benefit from a product
family approach. As a consequence, composition of components becomes
very complex. We describe how this complexity can be managed
automatically. The concepts and techniques presented are the first
step toward automated management of variability for web-based software
delivery.
- Paul Klint, Tijs van der Storm. Reflections on Feature Oriented
Software Engineering; accepted for the Workshop on
Managing Variabilities Consistently in Design and Code held at the
19th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages,
and Applications (OOPSLA 2004), [pdf] [abstract]
From the introduction:
Feature Oriented Software Engineering is
an emerging discipline in which feature models
are used to model the commonality and variability in a product
family. It is our that view product family engineering of very large
and highly variable systems cannot do without adequate tool
support. When the number of variants that have to be delivered and
maintained is exponential, automatization is not only desirable, but
inevitable.
- Gerco Ballintijn, Sjaak Brinkkemper, Paul Klint, Remy Jansen, Tijs van der Storm.
Intelligente levering van productsoftware, in:
Informatie, jan/feb, 2004 (in Dutch), [pdf].
- Tijs van der Storm. Narratief Verband (on Narrative Plot, Paranoia and Seership), Master's Thesis Theoretical Literature, Department of Humanities,
Universiteit van Amsterdam, 2004 (in Dutch), [pdf]
2003
- Tijs van der Storm. Implementing Actions,
Master's Thesis Computer Science, Department of Science, Mathematics and Computer Science, Universiteit van Amsterdam, 2003,
[pdf]
- Tijs van der Storm. AN2 Tools,
in: Proceedings of the Fourth International Workshop on Action Semantics (AS2002), [pdf].
Program Committees
