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've also co-organized the first Dutch Conference on Software Development Automation (SDA'13), which was 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 success factors, 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).
Tijs van der StormClick here to add to your contacts.CWIstorm@cwi.nlScience Park 1231098 XG, AmsterdamThe Netherlands+31205924164
Tijs van der Storm and Jurgen Vinju. Towards Multilingual Programming Environments. In: Science of Computer Programming (special issue on the occasion of Paul Klint's 65th birthday). To appear.
Abstract: Software projects consist of different kinds of artifacts: build files, configuration files, markup files, source code in different software languages, and so on. At the same time, however, most integrated development environments (IDEs) are focused on a single (programming) language. Even if a programming environment supports multiple languages (e.g., Eclipse), IDE features such as cross-referencing, refactoring, or debugging, do not often cross language boundaries. What would it mean for programming environment to be truly multilingual? In this short paper we sketch a vision of a system that integrates IDE support across language boundaries. We propose to build this system on a foundation of unified source code models and metaprogramming. Nevertheless, a number of important and hard research questions still need to be addressed.
Jan van Eijck and Tijs van der Storm. Understanding Information Update in Questionnaires. In: Science of Computer Programming (special issue on the occasion of Paul Klint's 65th birthday). To appear.
Abstract: Questionnaires are an important medium for collecting information in diverse areas of society (scientific surveys, tax filing, auditing guidance etc.). We are interested in a domain-specific language (DSL) to automatically generate questionnaire software from declarative specifications. This note describes an important aspect of the semantics of such a DSL: what goes on when users fill out a form? The formalism is based on the epistemic notion of information update and has a wide range of applications. It provides a formal interpretation for query forms, and for the process of answering such forms. The attractiveness of the approach is in the fact that asking questions, providing partial answers to questions, and providing full answers to questions, are all modeled by the same mechanism of constraining a range of possibilities.
Jeroen van den Bos and Tijs van der Storm. Trinity: and IDE for the Matrix. Under submission, 2013.
Abstract: Digital forensics software often has to be changed to cope with new variants and versions of file formats. Developers have to reverse engineer the actual files, and then change the source code of the analysis tools. This process is error-prone and time consuming because the relation between the newly encountered data and how the source code must be changed is implicit. TRINITY is an integrated debugging environment which makes this relation explicit using the DERRIC DSL for describing file formats. TRINITY consists of three simultaneous views: 1) the runtime state of an analysis, 2) a hexview of the actual data, and 3) the code representing a ﬁle format description. Cross-view traceability links allow developers to better understand how the file format description should be modiﬁed. As a result, the process of adapting digital forensics software becomes more effective and efﬁcient.
Sebastian Erdweg, Tijs van der Storm, Markus Völter, Meinte Boersma, Remi Bosman, William R. Cook, Albert Gerritsen, Angelo Hulshout, Steven Kelly, Alex Loh, Gabriël Konat, Pedro J. Molina, Martin Palatnik, Risto Pohjonen, Eugen Schindler, Klemens Schindler, Riccardo Solmi, Vlad Vergu, Eelco Visser, Kevin van der Vlist, Guido Wachsmuth, Jimi van der Woning. The State of the Art in Language Workbenches.
Conclusions from the Language Workbench Challenge. In: Proceedings of the 6th International Conference on Software Language Engineering (SLE'13). 2013.
Abstract: Language workbenches are tools that provide high-level mechanisms for the implementation of (domain-specific) languages. Language workbenches are an active area of research that also receives many contributions from industry. To compare and discuss existing language workbenches, the annual Language Workbench Challenge was launched in 2011. Each year, participants are challenged to realize a given domain-specific language with their workbenches as a basis for discussion and comparison. In this paper, we describe the state of the art of language workbenches as observed in the previous editions of the Language Workbench Challenge. In particular, we capture the design space of language workbenches in a feature model and show where in this design space the participants of the 2013 Language Workbench Challenge reside. We compare these workbenches based on a DSL for questionnaires that was realized in all workbenches.
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.
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.
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 deﬁning 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 deﬁning 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 reﬂection. Additionally, we also provide a modular mechanism to allow diﬀerent 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 eﬀectively 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).
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.
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: 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: 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.
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.
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.
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
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,
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]
- 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.
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.
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.
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),
- Tijs van der Storm,
Relational Meta-Modeling, in:
Relationships, Objects, Roles, and Queries in Modern Programming
Languages, Abstract. Dagstuhl Seminar Proceedings 10152, 2010.
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.
- 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.
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.
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,
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.
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 12th
European Conference on Software Maintenance and Reengineering (CSMR'08),
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.
- 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.
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.
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.
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.
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.
- 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]
- 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].