Merijn de Jonge

The ASF+SDF Meta-environment: A Component-Based Language Development Environment

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

Source Tree Composition

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

Feature-Based Product Line Instantiation Using Source-Level Packages

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

Software deployment in a dynamic cloud: From device to service orientation in a hospital environment

Hospital environments are currently primarily device-oriented: software services are installed, often manually, on specific devices. For instance, an application to view MRI scans may only be available on a limited number of workstations. The medical world is changing to a service-oriented environment, which means that every software service should be available on every device. However, these devices have widely varying capabilities, ranging from powerful workstations to PDAs, and high-bandwidth local machines to low-bandwidth remote machines. To support running applications in such an environment, we need to treat the hospital machines as a cloud, where components of the application are automatically deployed to machines in the cloud with the required capabilities and connectivity. In this paper, we suggest an architecture for applications in such a cloud, in which components are reliably and automatically deployed on the basis of a declarative model of the application using the Nix package manager.

Developing Product Lines with Third-Party Components

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.

Atomic upgrading of distributed systems

Upgrading distributed systems is a complex process. It requires installing the right services on the right computer, configuring them correctly, and so on, which is error-prone and tedious. Moreover, since services in a distributed system depend on each other and are updated separately, upgrades typically are not atomic: there is a time window during which some but not all services are updated, and a new version of one service might temporarily talk to an old version of another service. Previously we implemented the Nix package management system, which allows atomic upgrades and rollbacks on single computers. In this paper we show an extension to Nix that enables the deployment of distributed systems on the basis of a declarative deployment model, and supports atomic upgrades of such systems.

eServices for Hospital Equipment

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.

Decoupling Source Trees into Build-level Components

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.

Workshop on Generative Programming 2002 (GP2002)

Background. The goal of generative programming is to replace manual search, adaptation, and assembly of components with the automatic generation of needed components on demand. Generative technology has been in practical use for decades (e.g., compiler development, application generation, automatic configuration management, preprocessing, and meta-programming). However, developing new domain-specific languages (DSLs), application generators, and component generators has been extremely hard, as it requires being knowledgeable and experienced both in language design and compiler development. Recent developments such as XML technologies and template meta-programming revived the interest in generative programming by making it more accessible to developers.