[Toggle all BibTex references] [Toggle all abstracts]
Sander van der Burg, Eelco Dolstra, Disnix: A toolset for distributed deployment, In volume 79 of Science of Computer Programming (SCP), pages 52-69, Elsevier, January 2014. [bib] [abstract] [pdf]
BibTeX:
@article{vanderburg12disnix,
author = {Sander van der Burg and Eelco Dolstra},
title = {Disnix: A toolset for distributed deployment},
journal = {Science of Computer Programming (SCP)},
volume = {79},
publisher = {Elsevier},
pages = {52-69},
year = {2014},
month = {January},
}
Abstract:
The process of deploying a distributed system in a network of machines is often very complex, labourious and time-consuming, while it is hard to guarantee that the system will work as expected and that specific non-functional deployment requirements from the domain are supported. In this paper we describe the Disnix toolset, which provides system administrators or developers with automatic deployment of a distributed system in a network of machines from declarative specifications and offers properties such as complete dependencies, atomic upgrades and rollbacks to make this process efficient and reliable. Disnix has an extensible architecture, allowing the integration of custom modules to make the deployment more convenient and suitable for the domain in which the system is to be used. Disnix has been under development for almost four years and has been applied to several types of distributed systems, including an industrial case study.
Sander van der Burg, Eelco Dolstra, Shane McIntosh, Julius Davies, Daniel M. German, Armijn Hemel, Tracing Software Build Processes to Uncover License Compliance Inconsistencies, In 29th IEEE/ACM International Conference on Automated Software Engineering (ASE). Västerås, Sweden, ACM, September 2014. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{bdmdgh14tracing,
author = {Sander van der Burg and Eelco Dolstra and Shane McIntosh and Julius Davies and Daniel M. German and Armijn Hemel},
title = {Tracing Software Build Processes to Uncover License Compliance Inconsistencies},
booktitle = {29th IEEE/ACM International Conference on Automated Software Engineering (ASE)},
location = {Västerås, Sweden},
publisher = {ACM},
year = {2014},
month = {September},
}
Abstract:
Open Source Software (OSS) components form the basis for many software systems. While the use of OSS components accelerates development, client systems must comply with the license terms of the OSS components that they use. Failure to do so exposes client system distributors to possible litigation from copyright holders. Yet despite the importance of license compliance, tool support for license compliance assessment is lacking. In this paper, we propose an approach to construct and analyze the Concrete Build Dependency Graph (CBDG) of a software system by tracing system calls that occur at build-time. Through a case study of seven open source systems, we show that the constructed CBDGs: (1) accurately classify sources as included in or excluded from deliverables with 88%-100% precision and 98%-100% recall, and (2) can uncover license compliance inconsistencies in real software systems -- two of which prompted code fixes in the CUPS and FFmpeg systems.
Sander van der Burg, A Generic Approach for Deploying and Upgrading Mutable Software Components, In Danny Dig and Michael Wahler, editors, Fourth Workshop on Hot Topics in Software Upgrades (HotSWUp). Zurich, Switzerland, IEEE Computer Society, June 2012. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg12mutable,
author = {Sander van der Burg},
title = {A Generic Approach for Deploying and Upgrading Mutable Software Components},
booktitle = {Fourth Workshop on Hot Topics in Software Upgrades (HotSWUp)},
editor = {Danny Dig and Michael Wahler},
location = {Zurich, Switzerland},
publisher = {IEEE Computer Society},
year = {2012},
month = {June},
}
Abstract:
Deploying and upgrading software systems is typically a labourious, error prone and tedious task. To deal with the complexity of a software deployment process and to make this process more reliable, we have developed Nix, a purely functional package manager as well as an extension called Disnix, capable of deploying service-oriented systems in a network of machines. Nix and its applications only support deployment of immutable components, which never change after they have been built. However, not all components of a software system are immutable, such as databases. These components must be deployed by other means, which makes deployment and upgrades of such systems difficult, especially in large networks. In this paper, we analyse the properties of mutable components and we propose Dysnomia, a deployment extension for mutable components.
Sander van der Burg, Eelco Dolstra, A Self-Adaptive Deployment Framework for Service-Oriented Systems, In 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS). Waikiki, Honolulu, Hawaii, USA, ACM, May 2011. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg11selfadaptive,
author = {Sander van der Burg and Eelco Dolstra},
title = {A Self-Adaptive Deployment Framework for Service-Oriented Systems},
booktitle = {6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
location = {Waikiki, Honolulu, Hawaii, USA},
publisher = {ACM},
year = {2011},
month = {May},
}
Abstract:
Deploying components of a service-oriented system in a network of machines is often a complex and labourious process. Usually the environment in which such systems are deployed is dynamic: any machine in the network may crash, network links may temporarily fail, and so on. Such events may render the system partially or completely unusable. If an event occurs, it is difficult and expensive to redeploy the system to the take the new circumstances into account.
In this paper we present a self-adaptive deployment framework built on top of Disnix, a model-driven distributed deployment tool for service-oriented systems. This framework dynamically discovers machines in the network and generates a mapping of components to machines based on non-functional properties. Disnix is then invoked to automatically, reliably and efficiently redeploy the system.
Sander van der Burg, Eelco Dolstra, Disnix: A toolset for distributed deployment, In Mark van den Brand and Kim Mens and Holger Kienle and Anthony Cleve, editors, Third International Workshop on Academic Software Development Tools and Techniques (WASDeTT-3). Antwerp, Belgium, WASDeTT, September 2010. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg10disnix,
author = {Sander van der Burg and Eelco Dolstra},
title = {Disnix: A toolset for distributed deployment},
booktitle = {Third International Workshop on Academic Software Development Tools and Techniques (WASDeTT-3)},
editor = {Mark van den Brand and Kim Mens and Holger Kienle and Anthony Cleve},
location = {Antwerp, Belgium},
publisher = {WASDeTT},
year = {2010},
month = {September},
}
Abstract:
The process of deploying a distributed system in a network of machines is often very complex, labourious and time consuming, while it is hard to guarantee that the system will work as expected and that certain non-functional requirements from the domain are supported. In this paper we describe the Disnix toolset, which enables automatic deployment of a distributed system in a network of machines from declarative specifications and offers properties such as complete dependencies, atomic upgrades and rollbacks to make this process efficient and reliable. Disnix has an extensible architecture, allowing the integration of custom modules to build a distributed deployment architecture that takes non-functional requirements of the domain into account. Disnix has been under development for almost two years and has been applied to several types of distributed systems, including an industrial case study.
Sander van der Burg, Eelco Dolstra, Automating System Tests Using Declarative Virtual Machines, In 21st IEEE International Symposium on Software Reliability Engineering (ISSRE). San Jose, California, USA, IEEE Computer Society, November 2010. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg10automating,
author = {Sander van der Burg and Eelco Dolstra},
title = {Automating System Tests Using Declarative Virtual Machines},
booktitle = {21st IEEE International Symposium on Software Reliability Engineering (ISSRE)},
location = {San Jose, California, USA},
publisher = {IEEE Computer Society},
year = {2010},
month = {November},
}
Abstract:
Automated regression test suites are an essential software engineering practice: they provide developers with rapid feedback on the impact of changes to a system's source code. The inclusion of a test case in an automated test suite requires that the system's build process can automatically provide all the environmental dependencies of the test. These are external elements necessary for a test to succeed such as shared libraries, running programs, and so on. For some tests (e.g., a compiler's), these requirements are simple to meet.
However, many kinds of tests, especially at the integration or system level, have complex dependencies that are hard to provide automatically, such as running database servers, administrative privileges, services on external machines or specific network topologies. As such dependencies make tests difficult to script, they are often only performed manually, if at all. This particularly affects testing of distributed systems and system-level software.
This paper shows how we can automatically instantiate the complex environments necessary for tests by creating (networks of) virtual machines on the fly from declarative specifications. Building on NixOS, a Linux distribution with a declarative configuration model, these specifications concisely model the required environmental dependencies. We also describe techniques that allow efficient instantiation of VMs. As a result, complex system tests become as easy to specify and execute as unit tests. We evaluate our approach using a number of representative problems, including automated regression testing of a Linux distribution.
Sander van der Burg, Eelco Dolstra, Automated Deployment of a Heterogeneous Service-Oriented System, In 36th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA). Lille, France, IEEE Computer Society, September 2010. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg10automateddeployment,
author = {Sander van der Burg and Eelco Dolstra},
title = {Automated Deployment of a Heterogeneous Service-Oriented System},
booktitle = {36th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA)},
location = {Lille, France},
publisher = {IEEE Computer Society},
year = {2010},
month = {September},
}
Abstract:
Deployment of a service-oriented system in a network of machines is often complex and labourious. In many cases components implementing a service have to be built from source code for the right target platform, transferred to the right machines with the right capabilities and activated in the right order. Upgrading a running system is even more difficult as this may break the running system and cannot be performed atomically. Many approaches that deal with the complexity of a distributed deployment process only support certain types of components or specific environments, while general solutions lack certain desirable non-functional properties, such as atomic upgrading.This paper shows Disnix, a deployment tool which allows developers and administrators to reliably deploy, upgrade and roll back a service-oriented system consisting of various types of components in a heterogeneous environment from declarative specifications.
Sander van der Burg, Eelco Dolstra, Merijn de Jonge, Eelco Visser, Software Deployment in a Dynamic Cloud: From Device to Service Orientation in a Hospital Environment, In Kamal Bhattacharya and Martin Bichler and Stefan Tai, editors, First ICSE 2009 Workshop on Software Engineering Challenges in Cloud Computing. Vancouver, British Columbia, Canada, IEEE Computer Society, May 2009. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg09dynamiccloud,
author = {Sander van der Burg and Eelco Dolstra and Merijn de Jonge and Eelco Visser},
title = {Software Deployment in a Dynamic Cloud: From Device to Service Orientation in a Hospital Environment},
booktitle = {First ICSE 2009 Workshop on Software Engineering Challenges in Cloud Computing},
editor = {Kamal Bhattacharya and Martin Bichler and Stefan Tai},
location = {Vancouver, British Columbia, Canada},
publisher = {IEEE Computer Society},
year = {2009},
month = {May},
}
Abstract:
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.
Sander van der Burg, Eelco Dolstra, Merijn de Jonge, Atomic Upgrading of Distributed Systems, In Tudor Dumitras and Danny Dig and Iulian Neamtiu, editors, First ACM Workshop on Hot Topics in Software Upgrades (HotSWUp). Nashville, Tennessee, USA, ACM, October 2008. [bib] [abstract] [pdf]
BibTeX:
@inproceedings{vanderburg08atomicupgrading,
author = {Sander van der Burg and Eelco Dolstra and Merijn de Jonge},
title = {Atomic Upgrading of Distributed Systems},
booktitle = {First ACM Workshop on Hot Topics in Software Upgrades (HotSWUp)},
editor = {Tudor Dumitras and Danny Dig and Iulian Neamtiu},
location = {Nashville, Tennessee, USA},
publisher = {ACM},
year = {2008},
month = {October},
}
Abstract:
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.
Sander van der Burg, Julius Davies, Eelco Dolstra, Daniel M. German, Armijn Hemel, Discovering Software License Constraints: Identifying a Binary's Sources by Tracing Build Processes, Technical Report TUD-SERG-2012-010, Software Engineering Research Group, Delft, The Netherlands, April 2012. [bib] [abstract] [pdf]
BibTeX:
@techreport{BDDGH12,
author = {Sander van der Burg and Julius Davies and Eelco Dolstra and Daniel M. German and Armijn Hemel},
title = {Discovering Software License Constraints: Identifying a Binary's Sources by Tracing Build Processes},
number = {TUD-SERG-2012-010},
institution = {Software Engineering Research Group},
address = {Delft, The Netherlands},
year = {2012},
month = {April},
}
Abstract:
With the current proliferation of open source software components, intellectual property in general, and copyright law in particular, has become a critical non-functional requirement for software systems. A key problem in license compliance engineering is that the legal constraints on a product depend on the licenses of all sources and other artifacts used to build it. The huge size of typical dependency graphs makes it infeasible to determine these constraints manually, while mistakes can expose software distributors to litigation. In this paper we show a generic method to reverse-engineer this information from the build processes of software products by tracing system calls (e.g., open) to determine the composition graph of sources and binaries involved in build processes. Results from an exploratory case study of seven open source systems, which allowed us to discover a licensing problem in a widely used open source package, suggest our method is highly effective.
Sander van der Burg, Eelco Dolstra, Declarative Testing and Deployment of Distributed Systems, Technical Report TUD-SERG-2010-020, Software Engineering Research Group, Delft, The Netherlands, July 2010. [bib] [abstract] [pdf]
BibTeX:
@techreport{vanderburg10ddeploymentandtesting,
author = {Sander van der Burg and Eelco Dolstra},
title = {Declarative Testing and Deployment of Distributed Systems},
number = {TUD-SERG-2010-020},
institution = {Software Engineering Research Group},
address = {Delft, The Netherlands},
year = {2010},
month = {July},
}
Abstract:
System administrators and developers who deploy distributed systems have to deal with a deployment process that is largely manual and hard to reproduce. This paper describes how networks of computer systems can be reproducibly and automatically deployed from declarative specifications. Reproducibility also ensures that users can easily instantiate a test environment, before deploying the specification to the production environment. Furthermore, from the same specifications we can instantiate virtual networks of virtual machines for both interactive and automated testing. This makes it easy to write automated regression tests that require external machines, need special privileges, or depend on the network topology. We instantiate machines from the specifications using NixOS, a Linux distribution built from a purely functional specification. We have applied our approach to a number of representative problems, including automatic regression testing of a Linux distribution and deployment of a continuous integration environment.
Sander van der Burg, A Reference Architecture for Distributed Software Deployment, PhD thesis, Delft University of Technology, June 2013. [bib] [abstract] [pdf]
BibTeX:
@phdthesis{vanderburg13thesis,
author = {Sander van der Burg},
title = {A Reference Architecture for Distributed Software Deployment},
school = {Delft University of Technology},
year = {2013},
month = {June},
}
Abstract:
Nowadays, software systems are bigger and more complicated than people may think. Apart from the fact that a system has to be correctly constructed and should meet the client's wishes, they also have to be made ready for use to end-users or in an isolated test environment. This process is known as the software deployment process. Due to various developments, e.g. increasing complexity of requirements to a system and new techniques that have been developed to support these, the software deployment process has become increasingly more complicated and error prone. Especially for modern generation systems, often exposed as services through the Internet, such as Facebook and Twitter, an automated solution is required supporting important quality attributes, such as reliability, reproducibility, genericity, and efficiency as manual deployment is typically too time consuming and error prone. This dissertation describes a reference architecture that contains various components to automate software deployment processes of modern generation systems. These components strive to perform deployment steps in a way that is reliable, reproducible, generic, extensible and efficient.
Sander van der Burg, Model-driven Distributed Software Deployment, Master's thesis, Delft University of Technology, March 2009. [bib] [abstract] [pdf]
BibTeX:
@mastersthesis{vanderburg09thesis,
author = {Sander van der Burg},
title = {Model-driven Distributed Software Deployment},
school = {Delft University of Technology},
year = {2009},
month = {March},
}
Abstract:
The software deployment process, which involves all steps to make a software system available for use, is a complex process. Software systems can operate on just one machine but there are also many software systems with components running on multiple computers in a network that are working together to reach a common goal, which are called distributed systems. The software deployment process for distributed systems is more complex than for single systems, since we have dependencies which are on the same machine in the network, but also dependencies on components on other machines in the network. Components of systems in hospital environments are distributed and its deployment process is error prone and tedious.
In this thesis we extend a deployment system called Nix for single systems with new tools and models to make software deployment in distributed environments possible. The extension is called Disnix, which is a framework to make distributed deployment possible by reusing the Nix primitives.
This thesis also contains a case study where we used an existing distributed system for hospital environments developed at Philips Research which is called SDS2. We also adapted the SDS2 platform to fit in the Disnix framework and we identified some design constraints that should be met in order to make a system automatically deployable.
Sander van der Burg, Analyse kosten webapplicaties, Technical Report , Hogeschool Rotterdam, Rotterdam, The Netherlands, June 2005. HBO bachelor thesis (In Dutch). May only be published with permission from IBM Nederland B.V. [bib]
BibTeX:
@techreport{vanderburg05thesis,
author = {Sander van der Burg},
title = {Analyse kosten webapplicaties},
number = {},
institution = {Hogeschool Rotterdam},
address = {Rotterdam, The Netherlands},
year = {2005},
month = {June},
note = {HBO bachelor thesis (In Dutch). May only be published with permission from IBM Nederland B.V},
}