Navigation

Links

Introduction

About me

I am a researcher in the Software Analysis and Transformation Group at the Dutch research institute Centrum Wiskunde & Informatica (CWI). Currently 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.

Contact information

Tijs van der Storm

CWI

storm@cwi.nl

Science Park 123

1098 XG, Amsterdam

The Netherlands

+31205924164

Click here to add to your contacts.

Publications

Conference

• 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.

• 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.

• Tijs van der Storm, Backtracking Incremental Continuous Integration, in: Kostas Kontogiannis, Christos Tjortjis, Andreas Winter, editors, Proceedings of the 12^th 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, Binary Change Set Composition, in: H. W. Schmidt, I. Crnkovic, G. T. Heineman, J. A. Stafford, editors, Proceedings of the 10^th 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. To appear. [pdf] [bib] [abstract].

  Abstract: The Meta-Environment is a flexible framework for language development, source code analysis and source code transformation. We highlight new features and demonstrate how the system supports key functionalities for software evolution: fact extraction, software analysis, visualization, and software transformation.

• 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.

• 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.

Workshops

• 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.

Technical Reports

• Tijs van der Storm; Jurgen Vinju. Using the Meta-Environment for Domain Specific Language Engineering, CWI report SEN-R0805, 2008.
• Tijs van der Storm. Lightweight incremental application upgrade, CWI report SEN-R0604, 2006.
• Tijs van der Storm, Composing Configurable Java Components, CWI report SEN-R0503, 2005.
• P. Klint; T. van der Storm; J.J. Vinju. Term Rewriting meets Aspect-Oriented Programming, CWI report SEN-E0421, 2004.
• Tijs van der Storm. Variability and Component Composition, CWI report SEN-R0403, 2004.

Presentations

• Using the Meta-Environment for Model-Driven Engineering [odp] [pdf] [vimeo]
• Backtracking Incremental Continuous Integration [odp] [pdf]
• The Sisyphus Continuous Integration System [odp] [pdf]
• Binary Change-Set Composition [odp] [pdf]
• Generic Feature-Based Composition [odp] [pdf]
• Deliver: Knowledge-based Software Delivery [pdf] [odp] [swf] [ppt]
• Continuous Release and Upgrade of Component-Based Software [pdf]
• The Sisyphus Build System [pdf]
• Continuous Integration and Minimization of dependencies [pdf] [sxi] [ppt]
• Composing Configurable (Java) Components (Revised) [pdf]
• Composing Configurable Java Components [pdf] [ppt]
• Variability and Component Composition (Revised²) [pdf]
• Variability and Component Composition (Revised¹) [pdf]
• Variability and Component Composition [pdf]

Miscellaneous

• Ralf Lämmel and Tijs van der Storm, Crossing the Rubicon of API Migration, [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, Sisyphus: Continuous Integration of Component-Based Product Lines. Pacing the Heartbeat of Software Development, [poster], [abstract]
• 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. 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].

Literary Theory

• 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]

Activities

Program Committees

• LDTA'09

Master Software Engineering UvA

Courses

• Software Evolution
• Software Construction

For more info: see Master Software Engineering UvA.

Supervised Master's Theses

• N. Heirbaut, Two implementation techniques for Domain Specific Languages compared: OMeta/JS vs. JavaScript, [pdf], Universiteit van Amsterdam, 2009.
• J. van Lieshout, Benchmarken van een DSL implementatie in "Oslo" en C#, [pdf], Universiteit van Amsterdam, 2009 (in Dutch).
• M. de Graaf, Intelligent fuzzing of web applications, [pdf], Universiteit van Amsterdam, 2009.
• J.L. van Schagen, Measuring the quality of domain-specific language implementation approaches: Java versus ANTLR, [pdf], Universiteit van Amsterdam, 2009.
• A. Bij, Taking a JEE application offline: a comparative case-study, [pdf], Universiteit van Amsterdam, 2008.