Publications by Merijn de Jonge

Publications

2008

M. de Jonge. Developing Product Lines with Third-Party components. In A. Johnstone and J. Vinju (Ed.), Language Descriptions, Tools, and Applications (LDTA'08), Electronic Notes in Theoretical Computer Science, Budapest, Hungary. Elsevier Science Publishers, April 2008. To appear. [pdf] [bib]
```
@inproceedings{deJonge2008a,
   author       = {Merijn de Jonge},
   title        = {Developing Product Lines with Third-Party components},
   booktitle    = {Language Descriptions, Tools, and Applications (LDTA'08)},
   series       = {Electronic Notes in Theoretical Computer Science},
   publisher    = {Elsevier Science Publishers},
   year         = {2008},
   editor       = {A. Johnstone and J. Vinju},
   address      = {Budapest, Hungary},
   month        = {April},
   note         = {To appear}
}
```
[abstract]
Abstract: The trends toward product line development and toward adopting more third-party software are hard to combine. The reason is that product lines demand fine control over the software (e.g., for diversity management), while third-party software (almost by definition) provides only little or no control.
A growing use of third-party software may therefore lead to less control over the product development process or, vice-versa, requiring large control over the software may limit the ability to use third-party components. Since both are means to reduce costs and to shorten time to market, the question is whether they can be combined effectively.
In this paper, we describe our solution to this problem which combines the Koala component model developed within Philips with the concept of build-level components. We show that by lifting component granularity of Koala components from individual C files to build-level components, both trends can be united. The Koala architectural description language is used to orchestrate product composition and to manage diversity, while build-level components form the unit of third-party component composition.
L. C. Kuiper and M. de Jonge. Developing interactive web applications using the Google Web Toolkit. Technical report PR-TN 2008/00259, Healthcare Systems Architecture department, Philips Research, Eindhoven, The Netherlands, 2008. [bib]
```
@techreport{JTLR2007,
   author       = {Luuk C. Kuiper and Merijn de Jonge},
   title        = {Developing interactive web applications using the Google Web Toolkit},
   institution  = {Healthcare Systems Architecture department, Philips Research},
   year         = {2008},
   number       = {PR-TN 2008/00259},
   address      = {Eindhoven, The Netherlands}
}
```
[abstract]
Abstract: This document is written in the context of a Philips Research project on Clinical and Technical services for Philips Healthcare. In this project the usability of GWT was explored to develop interactive web applications in which movements of mobile devices in hospitals were visualized in real-time using a standard web browser. This report will reflect our experiences in using GWT.

2007

M. de Jonge, W. van der Linden and R. Willems. eServices for Hospital Equipment. In B. Krämer, K. Lin and P. Narasimhan (Ed.), Fifth International Conference on Service-Oriented Computing (ICSOC 2007), pages 391 - 397, Vienna, Austria. September 2007. [pdf] [bib]
```
@inproceedings{JLW2007,
   author       = {Merijn de Jonge and Wim van der Linden and Rik Willems},
   title        = {eServices for Hospital Equipment},
   booktitle    = {Fifth International Conference on Service-Oriented Computing (ICSOC 2007)},
   year         = {2007},
   editor       = {B. Kr\"amer and K.-J. Lin and P. Narasimhan},
   pages        = {391 -- 397},
   address      = {Vienna, Austria},
   month        = {September}
}
```
[abstract]
Abstract: In this paper we explore the idea that by combining different sources of information in a hospital environment, valuable e-services can be developed for reducing cost and improving quality of service.
Companies, like Philips Medical Systems, may have a competitive advantage, because they have a large installed base which may provide valuable information already, and because they can change their products
to provide additional information.
To optimally benefit from this advantage, we created a platform that enables quick development of e-services. The platform enables uniform access to data, combines static with live data, and supports transparent composition of existing, into new services.
We discuss the requirements, design, and implementation of the platform, and we show its use in a case study that addresses asset management and utilization services for mobile medical equipment.
A. Tešanović and M. de Jonge. Exploring Effects of Feature Mismatch to Evolution of Product Lines with Components and Aspects. Proceedings for Second Workshop on Aspect-oriented Product Line Engineering (AOPLE-2), pages 26 - 31, oct 2007. [pdf] [bib]
```
@inproceedings{TJ2007,
   author       = {Aleksandra Te\v{s}anovi\'{c} and Merijn de Jonge},
   title        = {Exploring Effects of Feature Mismatch to Evolution of Product Lines with Components and Aspects},
   booktitle    = {Proceedings for Second Workshop on Aspect-oriented Product Line Engineering (AOPLE-2)},
   year         = {2007},
   pages        = {26 -- 31},
   month        = {oct},
   url          = {http://www.softeng.ox.ac.uk/aople/}
}
```
[abstract]
Abstract: We explore the observation that the evolution of feature space and the evolution of components lead to a fundamental mismatch between features and their implementation in components. At one moment in time, a software system is structured in components in such a way that a given feature set can be mapped straight-forward to these components. Over time features and components evolve, leading to a situation where the mapping is less straightforward. A common indication is the need to deal with crosscutting features. In the end, the component structure that should improve software development hampers development because the implementation of individual features gets too much scattered around different components. We claim that using aspects for dealing with feature mismatch is beneficial in a short-term but can introduce additional problems in a long run, especially if aspects are used to mask architectural problems.
M. de Jonge, A. Tešanović, F. de Lange and J. Reuzel. Deployment Technologies: Hypecycled. Technical report PR-TN 2007/00426, Healthcare Systems Architecture department, Philips Research, Eindhoven, The Netherlands, 2007. [bib]
```
@techreport{JTLR2007,
   author       = {Merijn de Jonge and Aleksandra Te\v{s}anovi\'{c} and Fons de Lange and Joost Reuzel},
   title        = {Deployment Technologies: Hypecycled},
   institution  = {Healthcare Systems Architecture department, Philips Research},
   year         = {2007},
   number       = {PR-TN 2007/00426},
   address      = {Eindhoven, The Netherlands}
}
```
[abstract]
Abstract: This document gives a broad overview of software deployment for Philips Medical Systems. The emphasis is on software deployment in a service-oriented architecture. The document lists a large number of technologies, structured as state of practice, state of art, and state of research. Furthermore, each technology is placed on the Deployment Hypecycle to give a (subjective) indication of their position on the adoption timeline.

2006

L. Holenderski and M. de Jonge. Self-healing Process Networks. Philips Software Conference (PSC2006), nov 2006. [bib]
```
@inproceedings{HJ2006,
   author       = {Leszek Holenderski and Merijn de Jonge},
   title        = {Self-healing Process Networks},
   booktitle    = {Philips Software Conference (PSC2006)},
   year         = {2006},
   month        = {nov}
}
```
[abstract]
Abstract: In the Connected Planet vision, many Philips CE devices will be networked with other devices. In this paper we concentrate on the adaptation techniques which can be implemented in software that controls such devices. Ideally, the device should be able to change its behavior in response to any change in its environment that leads to the device's malfunction. Such fully adaptable devices are currently not feasible in practice. The best we can do at present is to try to increase the device's adaptability, by equipping it with software that can adapt at least in some cases.
A predominant technique used to increase a device's adaptability is to increase its interoperability with other devices in the network. In this paper we advocate to add other techniques which we call self-awareness and
self-healing. A self-aware device observes its own functioning in order to spot situations which can lead to its malfunctioning. When such a situation is observed it tries to remedy the problem (the self-healing phase).
We advocate to use process networks as the main programming paradigm for self-healing embedded applications. We claim that process networks are particularly easy to extend with self-healing capabilities.

2005

M. de Jonge. Build-Level Components. IEEE Transactions on Software Engineering, 31(7):588-600, 2005. [pdf] [bib]
```
@article{deJonge2005,
   author       = {Merijn de Jonge},
   title        = {Build-Level Components},
   journal      = {IEEE Transactions on Software Engineering},
   volume       = {31},
   year         = {2005},
   pages        = {588--600},
   number       = {7}
}
```
[abstract]
Abstract: Reuse between software systems is often not optimal. An important reason is that while at the functional level well-known modularization principles are applied for structuring functionality in modules, this is not the case at the build level for structuring files in directories. This leads to a situation where files are entangled in directory hierarchies and build processes, making it hard to extract functionality and to make functionality suitable for reuse. Consequently, software may not come available for reuse at all, or only in rather large chunks of functionality, which may lead to extra software dependencies.
In this paper we propose to improve this situation by applying component-based software engineering (CBSE) principles to the build level. We discuss how existing software systems break CBSE principles, we introduce the notion of build-level components, and we define rules for developing such components. To make our techniques feasible, we define a reengineering process for semi-automatically transforming existing software systems into build-level components. Our techniques are demonstrated in two case studies where we decouple the source tree of Graphviz into 46 build-level components, and analyze the source tree of Mozilla.

2004

E. Dolstra, G. Florijn, M. de Jonge and E. Visser. Transparantie in variabiliteit: Heldere keuzes in een eenduidige configuratieomgeving. Informatie, 46(1):18-21, February 2004. [pdf] [bib]

@article{DFJV2004,
   author       = {Eelco Dolstra and Gert Florijn and Merijn de Jonge and Eelco Visser},
   title        = {Transparantie in variabiliteit: Heldere keuzes in een eenduidige configuratieomgeving},
   journal      = {Informatie},
   volume       = {46},
   year         = {2004},
   pages        = {18--21},
   number       = {1},
   month        = {February}
}

E. Dolstra, E. Visser and M. de Jonge. Imposing a Memory Management Discipline on Software Deployment. In J. Estublier and D. Rosenblum (Ed.), 26th International Conference on Software Engineering (ICSE'04), pages 583-592, Edinburgh, Scotland. IEEE Computer Society, May 2004. [pdf] [bib]
```
@inproceedings{DVJ04,
   author       = {Eelco Dolstra and Eelco Visser and Merijn de Jonge},
   title        = {Imposing a Memory Management Discipline on Software Deployment},
   booktitle    = {26th International Conference on Software Engineering (ICSE'04)},
   year         = {2004},
   editor       = {J. Estublier and D. Rosenblum},
   pages        = {583--592},
   address      = {Edinburgh, Scotland},
   month        = {May},
   organization = {IEEE Computer Society},
   url          = {http://www.cs.uu.nl/groups/ST/Trace/ImposingAMemoryManagementDisciplineOnSoftwareDeployment}
}
```
[abstract]
Abstract: The deployment of software components frequently fails because dependencies on other components are not declared explicitly or are declared imprecisely. This results in an incomplete reproduction of the environment necessary for proper operation, or in interference between incompatible variants. In this paper we show that these deployment hazards are similar to pointer hazards in memory models of programming languages and can be countered by imposing a memory management discipline on software deployment. Based on this analysis we have developed a generic, platform and language independent, discipline for deployment that allows precise dependency verification; exact identification of component variants; computation of complete closures containing all components on which a component depends; maximal sharing of components between such closures; and concurrent installation of revisions and variants of components. We have implemented the approach in the Nix deployment system, and used it for the deployment of a large number of existing Linux packages. We compare its effectiveness to other deployment systems.
M. de Jonge. Decoupling Source Trees into Build-Level Components. In J. Bosch and C. Krueger (Ed.), Eighth International Conference on Software Reuse, LNCS, volume 3107, pages 215-231, Springer-Verlag, July 2004. [pdf] [bib]
```
@inproceedings{deJonge2004a,
   author       = {Merijn de Jonge},
   title        = {Decoupling Source Trees into Build-Level Components},
   booktitle    = {Eighth International Conference on Software Reuse},
   series       = {LNCS},
   volume       = {3107},
   publisher    = {Springer-Verlag},
   year         = {2004},
   editor       = {J. Bosch and C. Krueger},
   pages        = {215--231},
   month        = {July}
}
```
[abstract]
Abstract: Dividing software systems in components improves software reusability as well as software maintainability. Components live at several levels, we concentrate on the implementation level where components are formed by source files, divided over directory structures.
Such source code components are usually strongly coupled in the directory structure of a software system. Their compilation is usually controlled by a single global build process. This entangling of source trees and build processes often makes reuse of source code components in different software systems difficult. It also makes software systems inflexible because integration of additional source code components in source trees and build processes is difficult.
This paper's subject is to increase software reuse by decreasing coupling of source code components. It is achieved by automized assembly of software systems from reusable source code components and involves integration of source trees, build processes, and configuration processes. Application domains include generative programming, product-line architectures, and commercial off-the-shelf (COTS) software engineering.
E. Dolstra, M. de Jonge and E. Visser. Nix: A Safe and Policy-Free System for Software Deployment. In L. Damon (Ed.), 18th Large Installation System Administration Conference (LISA~'04), pages 79-92, Atlanta, Georgia, USA. USENIX, November 2004. [pdf] [bib]
```
@inproceedings{DJV04.lisa,
   author       = {Eelco Dolstra and Merijn de Jonge and Eelco Visser},
   title        = {Nix: A Safe and Policy-Free System for Software Deployment},
   booktitle    = {18th Large Installation System Administration Conference (LISA~'04)},
   year         = {2004},
   editor       = {Lee Damon},
   pages        = {79-92},
   address      = {Atlanta, Georgia, USA},
   month        = {November},
   organization = {USENIX},
   url          = {http://www.usenix.org/events/lisa04/}
}
```
[abstract]
Abstract: Existing systems for software deployment are neither safe nor sufficiently flexible. Primary safety issues are the inability to enforce reliable specification of component dependencies, and the lack of support for multiple versions or variants of a component. This renders deployment operations such as upgrading or deleting components dangerous and unpredictable. A deployment system must also be flexible (i.e., policy-free) enough to support both centralised and local package management, and to allow a variety of mechanisms for transferring components. In this paper we present Nix, a deployment system that addresses these issues through a simple technique of using cryptographic hashes to compute unique paths for component instances.
M. de Jonge. Multi-level Component Composition. In J. Bosch (Ed.), 2nd Groningen Workshop on Software Variability Modeling (SVM'04), Reseach Institute of Computer Science and Mathematics, University of Groningen, December 2004. [pdf] [bib]
```
@inproceedings{deJonge2004b,
   author       = {Merijn de Jonge},
   title        = {Multi-level Component Composition},
   booktitle    = {2nd Groningen Workshop on Software Variability Modeling (SVM'04)},
   year         = {2004},
   editor       = {Jan Bosch},
   number       = {2004-7-01},
   month        = {December},
   organization = {Reseach Institute of Computer Science and Mathematics, University of Groningen}
}
```
[abstract]
Abstract: Software components are a popular means to improve the practice of software engineering. They serve to increase productivity by promoting software reuse and increasing software quality. Component composition is the process of assembling software components. There are many forms of components, each demanding a specific form of composition. These are all orthogonal notions of the same principle of component-based software engineering.
We will explore the vision that software components are themselves compositions of components. This gives rise to the idea of composition levels, where compositions at level i serve as components at level i+1. As a consequence, components at different levels are not so independent as they are usually treated. One significant aspect of components that crosses component levels is variability.
In this paper, we will discuss preliminary work on multi-level composition. This includes general requirements for level-specific composition and a framework that supports multi-level composition.

2003

M. de Jonge. To Reuse or To Be Reused: Techniques for Component Composition and Construction. Phd thesis, University of Amsterdam, January 2003. [pdf] [bib]

@phdthesis{deJonge2003b,
   author       = {Merijn de Jonge},
   title        = {To Reuse or To Be Reused: Techniques for Component Composition and Construction},
   year         = {2003},
   month        = {January},
   school       = {University of Amsterdam}
}

E. Dolstra, G. Florijn, M. de Jonge and E. Visser. Capturing Timeline Variability with Transparent Configuration Environments. In J. Bosch and P. Knauber (Ed.), IEEE Workshop on Software Variability Management (SVM'03), Portland, Oregon. IEEE, May 2003. [pdf] [bib]
```
@inproceedings{DFJV2003,
   author       = {Eelco Dolstra and Gert Florijn and Merijn de Jonge and Eelco Visser},
   title        = {Capturing Timeline Variability with Transparent Configuration Environments},
   booktitle    = {IEEE Workshop on Software Variability Management (SVM'03)},
   publisher    = {IEEE},
   year         = {2003},
   editor       = {Jan Bosch and Peter Knauber},
   address      = {Portland, Oregon},
   month        = {May},
   url          = {http://www.cs.uu.nl/research/techreps/UU-CS-2003-051.html}
}
```
[abstract]
Abstract: Virtually every non-trivial software system exhibits variability: the property that the set of features - characteristics of the system that are relevant to some stakeholder - can be changed at certain points in the system's deployment lifecycle. Some features can be bound only at specific moments in the life-cycle, while some can be bound at several distinct moments (timeline variability). This leads to inconsistent configuration interfaces; variability decisions are generally made through different interfaces depending on the moment in the life-cycle. In this paper we propose to formalize variability into a feature model that takes timeline issues into account and to derive from such feature models configuration interfaces that abstract over the life-cycle.
M. de Jonge, J. Muskens and M. Chaudron. Scenario-Based Prediction of Run-time Resource Consumption in Component-Based Software Systems. 6th ICSE Workshop on Component-Based Software Engineering: Automated Reasoning and Prediction, May 2003. [pdf] [bib]
```
@inproceedings{JMC2003,
   author       = {Merijn de Jonge and Johan Muskens and Michel Chaudron},
   title        = {Scenario-Based Prediction of Run-time Resource Consumption in Component-Based Software Systems},
   booktitle    = {6th {ICSE} Workshop on Component-Based Software Engineering: Automated Reasoning and Prediction},
   year         = {2003},
   month        = {May}
}
```
[abstract]
Abstract: Resources of embedded systems, such as memory size and CPU power, are expensive and (usually) not extensible during the lifetime of a system. It is therefore desirable to be able to determine the resource consumption of an application as early as possible in the design phase. Only then, a designer is able to guarantee that an application will fit on a target device.
Resource prediction is a technique to estimate the amount of consumed resources by analyzing the design and/or implementation of an application. In this paper we concentrate on predicting memory consumption in component-based applications. Component-based applications complicate resource predictions because resource consumption is spread across individual components.
The challenge is to express resource consumption per component, and to combine them to do predictions over compositions of components. To that end, we propose a model in which individual resource estimations of components can be combined. These composed resource estimations are then used in scenarios (which model run-time behavior) to predict memory consumption of applications.
M. de Jonge. Package-Based Software Development. 29th Euromicro Conference, pages 76-85, IEEE Computer Society Press, September 2003. [pdf] [bib]
```
@inproceedings{deJonge2003a,
   author       = {Merijn de Jonge},
   title        = {Package-Based Software Development},
   booktitle    = {29th Euromicro Conference},
   publisher    = {IEEE Computer Society Press},
   year         = {2003},
   pages        = {76--85},
   month        = {September}
}
```
[abstract]
Abstract: The main goal of component-based software engineering is to decrease development time and development costs of software systems, by reusing prefabricated building blocks.
In this paper we focus on software reuse within the implementation of such component-based applications, and on the corresponding software development process. As it turns out, achieving effective reuse practice between the components of a single application and between the components of multiple applications has serious effects on the complexity of the software development process.
While software reuse demands for separation (of reusable blocks), the software development process demands for integration. Consequently, achieving optimal software reuse practice and an efficient development process are goals that seem hard to unite.
In this paper we discuss how these goals can be combined. We propose techniques that promote fine-grained software reuse across system, group, and institute boundaries, as well as integrated development of component compositions. The paper describes these techniques and demonstrates how they can be used in practice.

M. de Jonge. Component Models and Technologies: introduction from the session chair. 29th Euromicro Conference, pages 42, IEEE Computer Society Press, September 2003. [pdf] [bib]

@inproceedings{deJonge2003c,
   author       = {Merijn de Jonge},
   title        = {Component Models and Technologies: introduction from the session chair},
   booktitle    = {29th Euromicro Conference},
   publisher    = {IEEE Computer Society Press},
   year         = {2003},
   pages        = {42},
   month        = {September}
}

2002

M. de Jonge. Source Tree Composition. In C. Gacek (Ed.), Seventh International Conference on Software Reuse, LNCS, volume 2319, pages 17-32, Springer-Verlag, April 2002. [pdf] [bib]
```
@inproceedings{deJonge2002a,
   author       = {Merijn de Jonge},
   title        = {Source Tree Composition},
   booktitle    = {Seventh International Conference on Software Reuse},
   series       = {LNCS},
   volume       = {2319},
   publisher    = {Springer-Verlag},
   year         = {2002},
   editor       = {Cristina Gacek},
   pages        = {17--32},
   month        = {April}
}
```
[abstract]
Abstract: Dividing software systems in components improves software reusability as well as software maintainability. Components live at several levels, we concentrate on the implementation level where components are formed by source files, divided over directory structures.
Such source code components are usually strongly coupled in the directory structure of a software system. Their compilation is usually controlled by a single global build process. This entangling of source trees and build processes often makes reuse of source code components in different software systems difficult. It also makes software systems inflexible because integration of additional source code components in source trees and build processes is difficult.
This paper's subject is to increase software reuse by decreasing coupling of source code components. It is achieved by automized assembly of software systems from reusable source code components and involves integration of source trees, build processes, and configuration processes. Application domains include generative programming, product-line architectures, and commercial off-the-shelf (COTS) software engineering.
A. van Deursen, M. de Jonge and T. Kuipers. Feature-Based Product Line Instantiation using Source-Level Packages. In G. J. Chastek (Ed.), Second Software Product Line Conference (SPLC2), LNCS, pages 217-234, Springer-Verlag, August 2002. [pdf] [bib]
```
@inproceedings{DJK2002,
   author       = {Arie van Deursen and Merijn de Jonge and Tobias Kuipers},
   title        = {Feature-Based Product Line Instantiation using Source-Level Packages},
   booktitle    = {Second Software Product Line Conference (SPLC2)},
   series       = {LNCS},
   publisher    = {Springer-Verlag},
   year         = {2002},
   editor       = {G. J. Chastek},
   pages        = {217--234},
   number       = {2379},
   month        = {August}
}
```
[abstract]
Abstract: In this paper we discuss the construction of software products from customer-specific feature selections. We address variability management with the Feature Description Language (FDL) to capture variation points of product line architectures. We describe feature packaging which covers selecting and packaging implementation components according to feature selections using the autobundle tool. Finally, we discuss a generic approach, based on the abstract factory design pattern, to make instantiated (customer-specific) variability accessible in applications.
The solutions and techniques presented in this paper are based on our experience with the product line architecture of the commercial documentation generator
M. de Jonge. Pretty-Printing for Software Reengineering. International Conference on Software Maintenance (ICSM 2002), pages 550-559, IEEE Computer Society Press, October 2002. [pdf] [bib]
```
@inproceedings{deJonge2002b,
   author       = {Merijn de Jonge},
   title        = {Pretty-Printing for Software Reengineering},
   booktitle    = {International Conference on Software Maintenance (ICSM 2002)},
   publisher    = {IEEE Computer Society Press},
   year         = {2002},
   pages        = {550--559},
   month        = {October}
}
```
[abstract]
Abstract: Automatic software reengineerings change or repair existing software systems. They are usually tailor-made for a specific customer and language dependent. Maintaining similar reengineerings for multiple customers and different language dialects might therefore soon become problematic unless advanced language technology is being used.
Generic pretty-printing is part of such technology and is the subject of this paper. We discuss specific pretty-print aspects of software reengineering such as fulfilling customer-specific format conventions, preserving existing layout, and producing multiple output formats. In addition, we describe pretty-print techniques that help to reduce maintenance effort of tailor-made reengineerings supporting multiple language dialects.
Applications, such as COBOL reengineering and SDL documentation generation show that our techniques, implemented in the generic pretty-printer gpp, are feasible.
M. de Jonge. The Linux Kernel as Flexible Product-Line Architecture. Technical report SEN-R0205, CWI, Amsterdam, The Netherlands, 2002. [pdf] [bib]
```
@techreport{deJonge2002c,
   author       = {Merijn de Jonge},
   title        = {The {L}inux Kernel as Flexible Product-Line Architecture},
   institution  = {CWI},
   year         = {2002},
   number       = {SEN-R0205},
   address      = {Amsterdam, The Netherlands}
}
```
[abstract]
Abstract: The Linux kernel source tree is huge (> 125 MB) and inflexible (because it is difficult to add new kernel components). We propose to make this architecture more flexible by assembling kernel source trees dynamically from individual kernel components. Users then, can select what component they really need. Hardware vendors can easily support the Linux platform by providing additional separately developed kernel components.
We demonstrate how the kernel's build process can be setup for this approach and how individual build processes look like. We use a technique called source tree composition to assemble source trees of components. We demonstrate how it is automated by the tool autobundle. We also propose a kernel component base as central repository of kernel components. It forms a central meeting point for kernel developers and users.

2001

M. de Jonge and J. Visser. XT Capita Selecta. In E. Visser (Ed.), Second Stratego Users Day, February 2001. [pdf] [bib]
```
@inproceedings{JV2001b,
   author       = {Merijn de Jonge and Joost Visser},
   title        = {{XT} Capita Selecta},
   booktitle    = {Second Stratego Users Day},
   year         = {2001},
   editor       = {Eelco Visser},
   number       = {UU-CS-2001-54},
   month        = {February}
}
```
[abstract]
Abstract: XT is a bundle of program-transformation tools. Stratego is part of this bundle, and is used as implementation language for many tools throughout its packages. Giving special attention to the role of Stratego, we discuss a selection of our XT experiences. These range from the construction of meta-tools to support Stratego programming, through Stratego techniques applied in constructing some of XT�s constituents, to projects where XT (including Stratego and tools programmed in Stratego) has been applied to program-transformation problems.
M. van den Brand, A. van Deursen, J. Heering, H. de Jong, M. de Jonge, T. Kuipers, P. Klint, L. Moonen, P. Olivier, J. Scheerder, J. Vinju, E. Visser and J. Visser. The ASF+SDF Meta-Environment: a Component-Based Language Development Environment. In R. Wilhelm (Ed.), Compiler Construction 2001 (CC 2001), LNCS, volume 2027, pages 365-370, Springer-Verlag, April 2001. [pdf] [bib]
```
@inproceedings{ASFSDF2001,
   author       = {Mark van den Brand and Arie van Deursen and Jan Heering and Hayco de Jong and Merijn de Jonge and Tobias Kuipers and Paul Klint and Leon Moonen and Pieter Olivier and Jeroen Scheerder and Jurgen Vinju and Eelco Visser and Joost Visser},
   title        = {The {ASF+SDF Meta-Environment}: a Component-Based Language Development Environment},
   booktitle    = {Compiler Construction 2001 (CC 2001)},
   series       = {LNCS},
   volume       = {2027},
   publisher    = {Springer-Verlag},
   year         = {2001},
   editor       = {R. Wilhelm},
   pages        = {365--370},
   month        = {April}
}
```
[abstract]
Abstract: The ASF+SDF Meta-environment is an interactive development environment for the automatic generation of interactive systems for constructing language definitions and generating tools for them. Over the years, this system has been used in a variety of academic and commercial projects ranging from formal program manipulation to conversion of COBOL systems. Since the existing implementation of the ASF+SDF Meta-environment started exhibiting more and more characteristics of a legacy system, we decided to build a completely new, component-based, version. We demonstrate this new system and stress its open architecture.
M. de Jonge, E. Visser and J. Visser. XT: a bundle of program transformation tools (system description). In M. v. d. Brand and D. Parigot (Ed.), Language Descriptions, Tools and Applications (LDTA 2001), Electronic Notes in Theoretical Computer Science, volume 44, Elsevier Science Publishers, April 2001. [pdf] [bib]
```
@inproceedings{JVV2001b,
   author       = {Merijn de Jonge and Eelco Visser and Joost Visser},
   title        = {{XT}: a bundle of program transformation tools (system description)},
   booktitle    = {Language Descriptions, Tools and Applications (LDTA 2001)},
   series       = {Electronic Notes in Theoretical Computer Science},
   volume       = {44},
   publisher    = {Elsevier Science Publishers},
   year         = {2001},
   editor       = {Brand, Mark van den and Didier Parigot},
   month        = {April}
}
```
[abstract]
Abstract: XT bundles existing and newly developed program transformation libraries and tools into an open framework that supports component-based development of program transformations. We discuss the roles of XT�s constituents in the development process of program transformation tools, as well as some experiences with building program transformation systems with XT.
M. de Jonge and J. Visser. Grammars as Contracts. In G. Butler and S. Jarzabek (Ed.), Generative and Component-Based Software Engineering, Second International Symposium, GCSE 2000, Lecture Notes in Computer Science, volume 2177, pages 85-99, Erfurt, Germany. Springer, October 2001. [pdf] [bib]
```
@inproceedings{JV2001a,
   author       = {Merijn de Jonge and Joost Visser},
   title        = {Grammars as Contracts},
   booktitle    = {Generative and Component-Based Software Engineering, Second International Symposium, GCSE 2000},
   series       = {Lecture Notes in Computer Science},
   volume       = {2177},
   publisher    = {Springer},
   year         = {2001},
   editor       = {Greg Butler and Stan Jarzabek},
   pages        = {85--99},
   address      = {Erfurt, Germany},
   month        = {October}
}
```
[abstract]
Abstract: Component-based development of language tools stands in need of meta-tool support. This support can be offered by generation of code - libraries or full-fledged components - from syntax definitions. We develop a comprehensive architecture for such syntax-driven meta-tooling in which grammars serve as contracts between components. This architecture addresses exchange and processing both of full parse trees and of abstract syntax trees, and it caters for the integration of generated parse and pretty-print components with tree processing components.
We discuss an instantiation of the architecture for the syntax definition formalism SDF, integrating both existing and newly developed meta-tools that support SDF. The ATerm format is adopted as exchange format. This instantiation gives special attention to adaptability, scalability, reusability, and maintainability issues surrounding language tool development.
M. de Jonge and R. Monajemi. Cost-Effective Maintenance Tools for Proprietary Languages. International Conference on Software Maintenance (ICSM 2001), pages 240-249, IEEE Computer Society Press, November 2001. [pdf] [bib]
```
@inproceedings{JM2001,
   author       = {Merijn de Jonge and Ramin Monajemi},
   title        = {Cost-Effective Maintenance Tools for Proprietary Languages},
   booktitle    = {International Conference on Software Maintenance (ICSM 2001)},
   publisher    = {IEEE Computer Society Press},
   year         = {2001},
   pages        = {240--249},
   month        = {November}
}
```
[abstract]
Abstract: Maintenance of proprietary languages and corresponding tooling is expensive. Postponing maintenance to reduce these costs is an often applied, short-term solution which eventually may lead to an unoperational toolset. This paper describes a case study carried out in cooperation with Lucent Technologies where maintenance cost is decreased by simplifying the development process of languages and tools. The development process is simplified by using a language-centered software engineering approach which increases software reuse and language dependent code generation. The case study was concerned with Lucent's proprietary sdl dialect and involved the re-engineering of an SDL grammar and the construction of an SDL documentation generator.
M. de Jonge, E. Visser and J. Visser. Collaborative Software Development. Technical report SEN-R0113, CWI, Amsterdam, The Netherlands, 2001. [pdf] [bib]
```
@techreport{JVV2001a,
   author       = {Merijn de Jonge and Eelco Visser and Joost Visser},
   title        = {Collaborative Software Development},
   institution  = {CWI},
   year         = {2001},
   number       = {SEN-R0113},
   address      = {Amsterdam, The Netherlands}
}
```
[abstract]
Abstract: We present an approach to collaborative software development where obtaining components and contributing components across organizational boundaries are explicit phases in the development process. A lightweight generative infrastructure supports this approach with an online package base, and several generators that simplify the construction and composition of component packages. The infrastructure ensures availability, portability, and adaptability of components without centralized orchestration of the development process.

2000

M. de Jonge. A Pretty-Printer for Every Occasion. In I. Ferguson, J. Gray and L. Scott (Ed.), Proceedings of the 2nd International Symposium on Constructing Software Engineering Tools (CoSET2000), University of Wollongong, Australia, June 2000. [pdf] [bib]
```
@inproceedings{deJonge2000,
   author       = {Merijn de Jonge},
   title        = {A Pretty-Printer for Every Occasion},
   booktitle    = {Proceedings of the 2nd International Symposium on Constructing Software Engineering Tools (CoSET2000)},
   publisher    = {University of Wollongong, Australia},
   year         = {2000},
   editor       = {Ian Ferguson and Jonathan Gray and Louise Scott},
   month        = {June}
}
```
[abstract]
Abstract: Tool builders dealing with many different languages, and language designers require sophisticated pretty-print techniques to minimize the time needed for constructing and adapting pretty-printers. We combined new and existing pretty-print techniques in a generic pretty-printer that satisfies modern pretty-print requirements. Its features include language independence, customization, and incremental pretty-printer generation.
Furthermore, we emphasize that the recent acceptance of XML as international standard for the representation of structured data demands flexible pretty-print techniques, and we demonstrate that our pretty-printer
provides such technology.

1999

M. van den Brand and M. de Jonge. Pretty-Printing within the ASF+SDF Meta-Environment: a Generic Approach. Technical report SEN-R9904, CWI, Amsterdam, The Netherlands, 1999. [pdf] [bib]
```
@techreport{BJ1999,
   author       = {Mark van den Brand and Merijn de Jonge},
   title        = {Pretty-Printing within the {ASF+SDF} Meta-Environment: a Generic Approach},
   institution  = {CWI},
   year         = {1999},
   number       = {SEN-R9904},
   address      = {Amsterdam, The Netherlands}
}
```
[abstract]
Abstract: The automatic generation of formatters for (programming) languages within the ASF+SDF Meta-Environment is a research topic that is concerned with the construction of language specific formatters (or pretty-printers) given a language definition in SDF.
In this paper, we give an overview of pretty-printers that have been developed within this project and observe that these pretty-printers are either language dependent or non-customizable. Language independence and customizability are inevitable properties of pretty-printers however, when faced with the problem of formatting many different, evolving languages. Therefore, we introduce in this paper a generic framework for pretty-printing and describe an instantiation of the framework that forms a language independent and customizable pretty-printer.
M. de Jonge. boxenv.sty: A LaTeX Style File for Formatting BOX Expressions. Technical report SEN-R9911, CWI, Amsterdam, The Netherlands, 1999. [pdf] [bib]
```
@techreport{deJonge1999,
   author       = {Merijn de Jonge},
   title        = {boxenv.sty: A {LaTeX} Style File for Formatting {BOX} Expressions},
   institution  = {CWI},
   year         = {1999},
   number       = {SEN-R9911},
   address      = {Amsterdam, The Netherlands}
}
```
[abstract]
Abstract: BOX is a language independent mark-up language. It is designed for use within a generic pretty-print framework to connect source language dependent front-ends to target language dependent back-ends. A front-end translates a term over a language to BOX to describe its intended layout. Back-ends translate BOX terms to arbitrary output formats. The tool box2latex is a back-end that generates LaTeX code using specialized LaTeX commands and environments defined in the style file boxenv. This style file is required in order to process the generated document by LaTeX. This paper describes how to integrate the generated LaTeX files within your documents, and it describes the low-level interface and implementation of the boxenv style file.

M. de Jonge, T. Kuipers and J. Visser. HASDF: A Generalized LR-parser Generator for Haskell. Technical report SEN-R9902, CWI, Amsterdam, The Netherlands, 1999. [pdf] [bib]

@techreport{JKV1999,
   author       = {Merijn de Jonge and Tobias Kuipers and Joost Visser},
   title        = {{HASDF}: A Generalized {LR}-parser Generator for Haskell},
   institution  = {CWI},
   year         = {1999},
   number       = {SEN-R9902},
   address      = {Amsterdam, The Netherlands}
}

1997

M. de Jonge. Reuse of ASF+SDF Specifications by means of Renaming. University of Amsterdam, Programming Research Group, 1997. [bib]

@mastersthesis{deJonge1997,
   author       = {Merijn de Jonge},
   title        = {Reuse of {ASF+SDF} Specifications by means of Renaming},
   year         = {1997},
   number       = {P9718},
   school       = {{U}niversity of {A}msterdam, {P}rogramming {R}esearch {G}roup}
}

This web page is based on Eelco Dolstra's home page. $Date: 2008-02-27 15:04:20 +0100 (Wed, 27 Feb 2008), $ ($Rev: 313 $)