Steven te Brinke

A design method for modular energy-aware software

Nowadays reducing the overall energy consumption of software is important. A well-known solution is extending the functionality of software with energy optimizers, which monitor the energy consumption of software and adapt it accordingly. To make such extensions manageable and to cope with the complexity of the software, modular design of energy-aware software is necessary. Therefore, this paper proposes a dedicated design method for energy-aware software.

Thoughtful brute-force attack of the RERS 2012 and 2013 Challenges

The Rigorous Examination of Reactive Systems’ (rers) Challenges provide a forum for experimental evaluation based on specifically synthesized benchmark suites. In this paper, we report on our ‘brute-force attack’ of the rers 2012 and 2013 Challenges. We connected the rers problems to two state-of-the-art explicit state model checkers: LTSmin and Spin. Apart from an effective compression of the state vector, we did not analyze the source code of the problems. Our brute-force approach was successful: it won both editions of the rers Challenge.

Towards modular resource-aware applications

Resource optimization is an increasingly important requirement in the design and implementation of software systems. It is applied to improve both environmental sustainability and usability of resource-constrained devices. This paper claims that to achieve more modular resource-aware applications, the resource utilization of components must explicitly be modeled. Due to shortcomings of existing modeling languages, we propose a notation for the resource consumption of components and we illustrate the suitability of this notation by means of two real-world examples. We observe that explicitly modeling resource consumption has as result that resource consumption information is scattered across and tangled with the functional services of components.

A tool-supported approach for modular design of energy-aware software

The reduction of energy usage by software-controlled systems has many advantages, including prolonged battery life and reduction of greenhouse gas emissions. Thus, being able to implement energy optimization in software is essential. This requires a model of the energy utilization---or more general resource utilization---for each component in the system. Optimizer components, then, analyze resource utilization of other components in terms of such a model and adapt their behavior accordingly. We have devised a notation for Resource-Utilization Models (RUMs) that can be part of a components application programming interface (API) to facilitate the modular implementation of optimizers. In this paper, we present tools for extracting such RUMs from components with an existing implementation.

Reuse of continuation-based control-flow abstractions

It is commonly agreed that decomposing a software design according to the structure of the problem domain makes it easier to maintain and manage its complexity (e.g. [9]). To retain the resulting decomposition in the implementation, a programming language is needed that supports composition mechanisms that match the compositions in the problem domain. However, current programming languages only offer a small, fixed set of composition mechanisms. This leads to compromised implementations that either do not follow the decomposition from the design, or are cluttered with additional glue code. In this paper, we discuss the composition of control flow and investigate the hypothesis that continuations may be a suitable atomic core principle for offering a wide range of control-flow composition mechanisms in a form that does not compromise the structure and maintainability of the application. We present four variants of exception handling, which have been implemented using continuations and discuss their differences and commonalities. The results of this comparison are encouraging with respect to the expressiveness of continuations and reusability of implementations. But they also show that current language support for continuations leads to code replication and complex code.

Deriving minimal models for resource utilization

We show how compact Resource Utilization Models (RUMs) can be extracted from concrete overly-detailed models of systems or sub-systems in order to model energy-aware software. Using the Counterexample-Guided Abstraction Refinement (CEGAR) approach, along with model-checking tools, abstract models can be generated that help establish key properties relating to energy consumption. This approach is illustrated by the concrete example of a network manager sub-system. This work is part of an overall design methodology for energy-aware software.

A unified model of aspect-instantiation policies

One important concept in aspect-oriented execution environments is implicit invocation, typically supported through the pointcut-advice approach [13]. In this approach, functionality is given by an advice which is implicitly executed at execution points determined by pointcuts. In general, advices preserve state across multiple invocations and even multiple advices may share state. Aspect-oriented languages prevalently are extensions to class-based object-oriented languages, in which aspects extend the class concept and can be instantiated to objects at runtime. Aspect instances are used to store the state required by advice jointly defined in the same aspect, and advices are executed—similarly to usual methods—in the context of an aspect instance. Because advices are called implicitly, such aspect-oriented languages support the specification of so-called instantiation policies to define how to retrieve the aspect instance for the implicit invocation of advice. Dufour et al. [3] have found that aspect-instance look-up took more than 26% of the total execution time in selected use cases. Thus, it is important to research such policies and optimization opportunities. To this end, we suggest a unified model that conceptualizes instantiation policies to simplify and optimize the implementation of current and future instantiation policies in aspectoriented execution environments.

Interpreting energy profiles with CEGAR

There is an increasing demand for reducing the energy consumption of systems that are controlled by software. Energy is one of the resources that should be reduced, but since software often consumes higher-level resources which indirectly consume energy, it is important to model not only energy, but resource consumption in general. To facilitate modular implementation of resource optimization logic, we have proposed [1] to use so-called Resource-Utilization Models (RUMs), which express the relation between the dynamic behavior of the component and the resources it uses and provides as state transition diagrams expressing transitions---triggered by either service invocations or internal events---between states of stable resource consumption. We have shown how to use the CEGAR approach to automatically extract RUMs from existing component implementations. However, this approach does not measure any energy consumption; it assumes that energy information is available already, e.g.: as annotations in the source code or defined by the specification. Whereas this assumption holds in some cases, it is not applicable in general: Software libraries usually lack energy information. Therefore, to optimize energy consumption effectively, it is necessary that the energy consumption of such libraries can be profiled, so as to add energy information to the RUM.

Strata: Typed Semi-Structured Data in DokuWiki

A semantic wiki is a wiki that has a model of the knowledge contained in its pages. Currently, semantic wikis are not adopted by a large user base, because most implementations are research prototypes that implement their own wiki engine. To increase familiarity with semantic wikis and quick adoption of semantic technologies we present Strata, a plugin for the well known wiki DokuWiki. Strata allows the use of semi-structured data in any DokuWiki installation, normalizes values based on their types, and allows extensive data modeling and querying on complex data structures.

3rd international workshop on free composition (FREECO'12)

The history of programming languages shows a continuous search for new composition mechanisms to find better ways for structuring increasingly complex software systems into modules that can be developed and reused independently. Composition mechanisms can address various types of dependencies among modules, e.g., inheritance, delegation, aggregation, design patterns, contracts, explicit protocols, or domain-specific compositions. However, most languages adopt a fixed set of composition mechanisms, usually with explicit notation and predefined semantics. In case a language does not provide any mechanisms with the desired compositional behavior, programmers may need to write workarounds or introduce the new composition mechanism through macros, libraries, frameworks or language extensions. This workshop intends to stimulate research in programming languages and software development by exploring the notion that todays languages with their limited set of composition mechanisms is insufficient. Instead we should allow compositions that support more flexibility, adopt a wide variety of compositions, domain-specific and tailored compositions, or programmable compositions of various program artifacts.