Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time.
Both crosscutting concerns and feature interactions are phenomena that may impair modularity. Crosscutting concerns have been in the center of interest in aspect-oriented software development. Much research in this direction—including my own—is aimed at developing mechanisms to avoid and manage code scattering and tangling, with a strong focus on source-code organization. Feature interactions have been studied even earlier. Research on feature interactions always emphasized behavioral aspects that arise when two features interact, regardless of the implementation. Both phenomena are related, but not as closely as one may think. In this talk, I will tell my personal story on how I started my research career with investigating crosscutting concerns and—after a long journey and many misunderstanding and enlightments—arrived at being interested in feature interactions. In some sense this journey is also a journey of a whole community that emerged from different research areas, and I will share my experience gathered from this journey and synthesize lessons learned. In particular, I will highlight the (historical) differences of research on crosscutting concerns and feature interactions. Furthermore, by means of recent experimental results, I will emphasize that there are different types of feature interactions and that these type are related (some to crosscutting concerns). I will close the talk with a call to action to accept and approach the New Feature Interaction Challenge, which is to understand and exploit the different types of feature interactions to build better software (e.g., to develop better tools for feature-interaction testing).
Allowing end-users to extend and adapt applications can speedup software evolution and serve as a pedagogical tool for programming. Alas even open-ended architectures (like the Emacs architecture) presuppose a significant familiarity with programming languages and tools for end-users. General visual programming (as in the case of blocks) offers a more gentle alternative but still introduces additional tools and cognitive abstractions for prospective developers. We propose a possible third alternative: the direct mapping of reflective and meta-programming facilities onto base-level notions and interfaces through an additional self representation model, the projection layer. Our main hypothesis is that for certain types of applications used by non programmers (like for e.g., simulation software) this projection to the base-level has the potential to open a more gradual learning path for programming extensions, by using the same UI and abstractions that the end-user is already familiar with. This position paper analyses our approach and describes our on-going efforts to support or refute our hypothesis through a case-study on software for crisis assessment.
Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this paper is to define, categorise and compare key concepts shared by these approaches. Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them.
Wallingford is an experimental constraint reactive programming language that supports objects with state, persistent constraints on those objects, and reactive constraints that enable the system to respond to events by declaring constraints that become active when an event occurs, or while a condition holds. It is implemented in Rosette, a solver-aided programming language and environment for constructing DSLs in turn implemented in Racket. This short paper is a snapshot of work-in-progress on the system.
Every fragment of code we write has dependencies and associated metadata. Code dependencies range from local references and standard library definitions to external third party libraries. Metadata spans from within source code files (hierarchical names and code comments) to external files and database servers (package-level dependency configurations, build and test results, code reviews etc.). This scattered storage and non-uniform access limits our programming environments in their functionality and extensibility. In this paper, we propose a modular system architecture, Haknam, better suited for code and related metadata sharing. Haknam precisely tracks code interdependencies, allows flexible naming and querying of code references, and collects code fragments and their related metadata as messages in a distributed log-centric pipeline. We argue that this setting brings considerable advantages. In particular, we focus on modular development of tools and services that can assist in programming-related tasks. Every new functionality can be simply added by creating and processing messages from the distributed pipeline.
In today's systems we often plug together configurable standard components in a modular way. Most software, however, does not specify its configuration in a way suitable for other software. The aim of our configuration specification language SpecElektra is to fill this gap. It allows us to externally specify the configuration items of non-standardized configuration files. In SpecElektra we assign properties that enable additional validations and transformations. As a result, we can safely and easily configure software at run-time. The approach integrates standard software while retaining its modularity. We demonstrate how high-level configuration items help us to cope with changes in system-oriented goals.
Use cases are a practically proven choice to concisely and precisely express what highly interactive systems do. Several attempts have been made to modularize code according to use cases. None of these approaches is able to gather all the code related to a use case in one module and to reflect its steps. However, to allow for code to be modularized according to use case flows and their steps, an instrumentation environment is necessary. In this paper, literal multi-language use case coding based on defragmentation is proposed. The approach aims at fully preserving use case flows in as comprehensible form as possible. The steps of use case flows appear directly in the code as comments. Despite being comments, the steps are active, which is achieved by a dedicated preprocessor and framework. The detailed step implementation gathers all the code fragments of each step each of which may be in a different programming language.
In this paper, we introduce a new functional reactive programming (FRP) language Emfrp designed to support small-scale embedded systems. An Emfrp program defines a system as a fixed directed graph whose nodes correspond to the time-varying values in the system. The language equips a simple mechanism that enables each node to refer the past values of arbitrary nodes. Using this mechanism, Emfrp provides simplicity and flexibility for describing complex time-dependent reactive behaviors without space and time leaks. Our Emfrp compiler produces platform-independent ANSI-C code that can run on multiple processors including resource constrained microcontrollers. To demonstrate the capabilities of the language, we show a simple but non-trivial example application.
A constraint is a declarative description of a relation that we want to have hold, for example, that a set of icons be equally spaced and positioned at the bottom of a window, or that a resistor in an electrical circuit simulation obey Ohm’s Law. A constraint can support modularity in programs by providing a succinct way to express some property, in a way that lets it be combined flexibly with other constraints. Historically there have been two principal views of constraints in programing languages: as equations to be solved, or as relations to be maintained in the face of change. In this talk I’ll concentrate on the second view and how such constraints can be used in building interactive systems. There is a long history of work in this area. A key early system was Ivan Sutherland’s Sketchpad from 1963 [5]; a less notable but still early system was my own ThingLab from 1979 [1]. In this talk I’ll describe a little of that history, including a demo of a revived version of ThingLab, using the original code from 1979 running in a web browser using an interpreter written in Javascript. I’ll then describe some recent work on constraints for interactive systems, including Babelsberg and Wallingford. Babelsberg [3, 4] is a family of object constraint languages that allows constraints to be integrated with an existing object-oriented language. In particular, Babelsberg enables the programmer to write constraints that include object-oriented constructs such as message sends and that respect object encapsulation, as well as explicit constraints on object identity. Finally, Wallingford [2] is a new constraint reactive programming language implemented in the Rosette solver-aided programming language [6, 7]. Wallingford adopts many of the approaches in Babelsberg to integrating constraints and object-oriented programming, and adds reactive constraints that enable the system to respond to events by declaring constraints that become active when an event occurs, or while a condition holds.
Protected Module Architectures are a new brand of security architectures whose main objective is to support the secure isolated execution of software modules with a minimal Trusted Computing Base (TCB) - several prototypes for embedded systems (and also the Intel Software Guard eXtensions for higher-end systems) ensure isolation with a hardware-only TCB. However, while these architectures offer strong confidentiality and integrity guarantees for software modules, they offer no availability (let alone real-time) guarantees. This paper reports on our work-in-progress towards extending a protected module architecture for small microprocessors with availability and real-time guarantees. Our objective is to maintain the existing security guarantees with a hardware-only TCB, but to also guarantee availability (and even real-time properties) if one can also trust the scheduler. The scheduler, as any software on the platform, remains untrusted for confidentiality and integrity but it is sufficient to trust the scheduler module to get availability guarantees even on a partially compromised platform.
Reflection and extensibility in object-oriented programming languages can be supported by meta-object protocols (MOP) that define class-based interfaces over data representation and execution features. MOPs are typically dynamic in the sense that type-based dispatching is used to select between feature implementations at run time leading to a significant difference in execution speed compared to non-MOP-based languages. Defining a corresponding static-MOP would seem to be a solution whereby type-dispatching can occur at compile time. Such an approach requires the integration of a static type system with a MOP. This paper introduces a new reflective and extensible language called JMF written in Java that aims to generate efficient code through the use of a static-MOP. The contribution of this paper is to characterise a static-MOP and to show how it integrates with a type system for JMF.
Model-Driven Engineering (MDE) proposes to modularize complex software-intensive systems using multiple models where each module serves a specific concern. These concerns of a system might be diverse and the use of multiple heterogeneous models often becomes inevitable. These models adhere to different paradigms and use distinct formalisms, which makes it hard to ensure consistency among them. Moreover, these models might contain certain concepts ( at times overlapping) that are reused for building cross-concern views/models. Maintaining models using separation of concerns in a heterogeneous modeling space becomes difficult. Traditional MDE suggests the use of model transformations to maintain the mappings between heterogeneous models. In this paper, we introduce a different approach based on model federation to map heterogeneous models. In contrast to traditional approaches where heterogeneous models are gathered in a single technological space, model federation keeps them in their own technological spaces. We provide a mechanism so that elements of these models are accessible for the development of cross-concern views/models from their respective technological spaces.
We propose an advice mechanism called Chop&Graft for non-local flow control. It offers a novel chop pointcut that lets a piece of advice terminate the current execution, and graft and retry operators that resume and restart the terminated executions. By using pointcuts for specifying the region of termination, the mechanism is more robust and more concise than the traditional exception handling mechanisms that rely on names or exception classes. The paper presents the design of the mechanism along with the sketches of two implementations using delimited continuations or threads and exceptions.
The skeletal implementation pattern is a software design pattern consisting of defining an abstract class that provides a partial interface implementation. However, since Java allows only single class inheritance, if implementers decide to extend a skeletal implementation, they will not be allowed to extend any other class. Also, discovering the skeletal implementation may require a global analysis. Java 8 enhanced interfaces alleviate these problems by allowing interfaces to contain (default) method implementations, which implementers inherit. Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself. We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced interface feature for their legacy Java software.
A significant concern in verification research is the ability to reason modularly about programs with state. Recent work has used substructural logics including separation logic , permissions, and Hoare Type Theory to specify each function in terms of its effect on its footprint. The motivation of our work is the need for formal specifications that allow one to hide shared data between two abstractions. In 2014, we proposed object propositions as an automatable extension to abstract predicates. We allow state to be shared between two objects, by providing fractional permissions to access the common data hidden in a predicate, without revealing this sharing in the objects' specifications. Unlike conventional object invariant and ownership-based work, our system allows ownership transfer by passing unique permissions (permissions with a fraction of 1) from one reference to another. Unlike separation logic and permission systems, we can modify objects without owning them. This has information-hiding and system-structuring benefits.
Maintaining consistency between data throughout a system using scattered, imperative code fragments is challenging. Some mechanisms address this challenge by making data dependencies explicit. Among these mechanisms are reactive collections, which define data dependencies for collections of objects, and object queries, which allow developers to query their program for a subset of objects. However, on their own, both of these mechanisms are limited. Reactive collections require an initial collection to apply reactive operations to and object queries do not update its result as the system changes. Using these two mechanisms in conjunction allows each to mitigate the disadvantage of the other. To do so, object queries need to respond to state changes of the system. In this paper, we propose a combination of both mechanisms, called reactive object queries. Reactive object queries allow the developer to declaratively select all objects in a program that match a particular predicate, creating a view. Additionally, views can be composed of other views using reactive operations. All views are automatically updated when the program state changes. To better integrate with existing imperative systems, we provide fine-grained events signaling view updates. We implemented the proposed concepts in JavaScript. Our initial experience with example applications shows that the combined concept eases the integration of reactive mechanisms with object-oriented environments by avoiding scattered update code.
Consider the task of auditing an application whose main functionality is to execute commands received from clients. One could audit command executions with AspectJ. Alternatively, one could design, implement, and use a domain-specific aspect language for auditing, and then throw the language away. In this paper we argue that such disposable aspect languages are useful and that developing them may overall be as cost-effective as using general-purpose aspect languages.
Reuse is essential in modern software engineering, and hence also in the context of model-driven engineering (MDE). Concern-Oriented Reuse (CORE) proposes a new way of structuring model-driven software development where models of the system are modularized by domains of abstraction within units of reuse called concerns. Within a concern, models are further decomposed and modularized by views and features. High-level concerns can reuse lower-level concerns, and models within a concern can extend other models belonging to the same concern, resulting in complex inter- and intra-concern dependencies. To clearly specify what dependencies are allowed between models belonging to the same or to different concerns, CORE advocates a three-part interface to describe each concern (variation, customization, and usage interfaces). This paper presents the CORE metamodel that formalizes the CORE concepts and enables the integration of different mod- elling languages within the CORE framework.
Population, environmental, and technological changes are reshaping the infrastructure of our urban environments, and will be a major focus of attention in the near future. Cities have always accommodated new technologies, such as the invention and widespread use of motorized vehicles, mass transportation, and recently, electric vehicles. Yet every new technology brings with it challenges in policy making. With the advent of alternative energy and and the Internet of Things, there is suddenly a plethora of new technologies that will require major restructuring of cities. Some examples are electric and autonomous vehicles, solar energy, unmanned aerial vehicles, and smart homes and buildings. In order to establish sound public policies, all these new technologies can greatly benefit from urban simulations, to measure their impact on the city and its people before the policies are defined.
