Sebastián González

Highly dynamic behaviour adaptability through prototypes with subjective multimethods

With the advent of ambient intelligence and advances in mobile hardware technology, the next generation of software systems will require the ability to gracefully and dynamically adapt to changes in their surrounding environment. Contemporary languages provide no dedicated support to this end, thus requiring software developers to achieve this run-time adaptability through the use of specific design patterns and architectural solutions. As a consequence, all possible variability points of mobile systems need to be anticipated up front. Instead, we aim at solving the problem at the language level. We propose a new programming language called Ambience that provides dedicated language mechanisms to manage changing contexts and deal with run-time adaptation of mobile applications to those contexts. The language abstractions we propose are based on a prototype-based programming model that features multimethods and subjective object behaviour. We illustrate and motivate our approach by means of two running examples that were implemented in our language.

Using intentional source-code views to aid software maintenance

The conceptual structure of existing software systems is often implicit or non-existing in the source code. We propose the lightweight abstraction of intentional source-code views as a means of making these conceptual structures more explicit. Based on the experience gained with two case studies, we illustrate how intentional source-code views can simplify and improve software understanding, maintenance and evolution in various ways. We present the results as a catalog of usage scenarios in a pattern-like format.

Context traits: dynamic behaviour adaptation through run-time trait recomposition

Context-oriented programming emerged as a new paradigm to support fine-grained dynamic adaptation of software behaviour according to the context of execution. Though existing context-oriented approaches permit the adaptation of individual methods, in practice behavioural adaptations to specific contexts often require the modification of groups of interrelated methods. Furthermore, existing approaches impose a composition semantics that cannot be adjusted on a domain-specific basis. The mechanism of traits seems to provide a more appropriate level of granularity for defining adaptations, and brings along a flexible composition mechanism that can be exploited in a dynamic setting. This paper explores how to achieve context-oriented programming by using traits as units of adaptation, and trait composition as a mechanism to introduce behavioural adaptations at run time. First-class contexts reify relevant aspects of the environment in which the application executes, and they directly influence the trait composition of the objects that make up the application. To resolve conflicts arising from dynamic composition of behavioural adaptations, programmers can explicitly encode composition policies. With all this, the notion of context traits offers a promising approach to implementing dynamically adaptable systems. To validate the context traits model we implemented a JavaScript library and conducted case studies on context-driven adaptability.

Features on demand

This paper presents our vision of applications as feature clouds, providing software services that are composed dynamically from a set of available fine-grained features. Our feature cloud programming model realizing this vision, relies on context-oriented programming technology, enabling new or adapted features to be added to or removed from running applications on demand, according to contextual information, and taking into account feature dependencies. As a proof of concept, we implemented a prototype of an on-board car system running on a mobile device, using an instantiation of our feature clouds programming model for JavaScript.

Modeling and Analyzing Self-Adaptive Systems with Context Petri Nets

The development of self-adaptive systems requires the definition of the parts of the system that will be adapted, when such adaptations will take place, and how these adaptations will interact with each other. However, foreseeing all possible adaptations and their interactions is a difficult task, opening the possibility to inconsistencies or erroneous system behavior. To avoid inconsistencies, self adaptive systems require a sound programming model that allows to reason about the correctness of the system in spite of its dynamic reconfigurations. This paper presents context Petri nets, a Petri net-based programming model for self-adaptive systems. This model provides a formal definition of adaptations and their interaction, as well as a consistent process for their inclusion in the system. Besides serving as an underlying run-time model to ensure that adaptations and their constraints remain consistent, context Petri nets allow to analyze properties such as reachability, and liveness in the configuration of self-adaptive systems. Context Petri nets thus are a convenient tool to model and analyze the dynamics of self-adaptive systems, both formally and computationally.

Semantics for Consistent Activation in Context-Oriented Systems

Context: Context-oriented programming languages provide dedicated programming abstractions to define behavioral adaptations and means to combine those adaptations dynamically according to sensed context changes. Some of these languages feature programming abstractions to explicitly define interaction dependencies among contexts. However, the semantics of context activation and the meaning of dependency relations have been described only informally, which in some cases has led to incorrect specifications, faulty implementations and inconsistent system behavior. Objective: With the aim of avoiding faulty implementations and inconsistencies during system execution, this paper proposes both a formal and run-time model of contexts, context activation and context interaction. Method: As a formal and computational basis, we introduce context Petri nets, a model based on Petri nets, which we found to match closely the structure of contexts in context-oriented systems. The operational semantics of Petri nets permits the modeling of run-time context activations, and existing Petri net analyses allow to reason about system properties. As validation, we carried out small and medium-sized case studies. Results: In the explored cases, Context Petri nets served effectively as underlying run-time model to ensure that declared context interaction constraints remain consistent during context manipulation. Moreover, context Petri nets enabled us to analyze certain properties regarding the activation state of particular contexts. Conclusion: Context Petri nets thus proved to be an appropriate formalism to encode and manage the semantics of context activation, both formally and computationally, so as to preserve the consistency of context-oriented systems.

Safer context (de)activation: through the prompt-loyal strategy

Context-oriented programming languages provide language abstractions for the dynamic activation and deactivation of behavioral adaptations, based on the systems context of execution. As contexts are freely activated and deactivated, their associated behavior adaptations are added and removed to and from the system, which may break its consistency with respect to other available adaptations. To manage consistency between adaptations this paper introduces a model for the safe activation and deactivation of contexts. The model consists of two approaches, prompt-loyal for a delayed context (de)activation, and prompt for an immediate context (de)activation.

Predicated Generic Functions

This paper presents predicated generic functions, a novel programming language abstraction that allows the expression of context-dependent behaviour in a declarative and modular manner, providing fine-grained control of method applicability and method specificity. Methods are guarded by predicates with user-defined orderings, thereby increasing the expressiveness of existing method dispatching approaches. We have prototyped our proposal in Lambic, an extension of the standard Common Lisp Object System. We illustrate and motivate our approach by discussing the implementation of a collaborative graphical editor.

Uniting global and local context behavior with context Petri nets

Context-oriented programming enables adaptation of systems to their execution environment. Behavioral adaptations are defined in the system and then associated to a context. Such adaptations are made available at runtime when their context is deemed more appropriate by the execution environment. Context activation is reified using two techniques. Global to all running threads in the system, or local to a particular thread of execution. Providing one technique or the other may hinder the adaptable capabilities of the system. This paper extends the context Petri nets model to unify global and local context behavior. Global and local context behavior are represented as multicolored tokens in context Petri nets, by assigning a color to each thread in the system. By means of context Petri nets, context-oriented systems can unambiguously adapt their behavior globally, or to a particular thread of execution.

Transactional contexts: harnessing the power of context-oriented reflection

The emerging field of context-oriented programming gives a predominant role to the execution context of applications, and advocates the use of dedicated mechanisms to allow the elegant expression of behavioural adaptations to such context. With suitable reflective facilities, language semantics can be adapted to context by reusing the same context-oriented mechanisms that allow base-level adaptability. This kind of meta-level adaptability, in which the computation model itself becomes adaptable to context, gives rise to context-oriented computational reflection. To explore this idea, we set out to implement a simple software transactional memory system that exploits meta-level adaptability by regarding transactions as contexts, and adapting fundamental system behaviour to such transactional contexts. The implementation is succinct and non-intrusive, giving us an indication of the power lying at the crossroads of context-oriented programming and computational reflection.