Modeling Features at Runtime

A feature represents a functional requirement fulfilled by a system. Since many maintenance tasks are expressed in terms of features, it is important to establish the correspondence between a feature and its implementation in source code. Traditional approaches to establish this correspondence exercise features to generate a trace of runtime events, which is then processed by post-mortem analysis. These approaches typically generate large amounts of data to analyze. Due to their static nature, these approaches do not support incremental and interactive analysis of features. We propose a radically different approach called live feature analysis, which provides a model at runtime of features. Our approach analyzes features on a running system and also makes it possible to grow feature representations by exercising different scenarios of the same feature, and identifies execution elements even to the sub-method level. We describe how live feature analysis is implemented effectively by annotating structural representations of code based on abstract syntax trees. We illustrate our live analysis with a case study where we achieve a more complete feature representation by exercising and merging variants of feature behavior and demonstrate the efficiency or our technique with benchmarks.

Capturing How Objects Flow At Runtime

Most of today's dynamic analysis approaches are based on method traces. However, in the case of object-orientation understanding program execution by analyzing method traces is complicated because the behavior of a program depends on the sharing and the transfer of object references (aliasing). We argue that trace-based dynamic analysis is at a too low level of abstraction for object-oriented systems. We propose a new approach that captures the life cycle of objects by explicitly taking into account object aliasing and how aliases propagate during the execution of the program. In this paper, we present in detail our new meta-model and discuss future tracks opened by it.

Unanticipated Partial Behavioral Reflection: Adapting Applications at Runtime

Dynamic, unanticipated adaptation of running systems is of interest in a variety of situations, ranging from functional upgrades to on-the-fly debugging or monitoring of critical applications. In this paper we study a particular form of computational reflection, called unanticipated partial behavioral reflection, which is particularly well-suited for unanticipated adaptation of real-world systems. Our proposal combines the dynamicity of unanticipated reflection, i.e. reflection that does not require preparation of the code of any sort, and the selectivity and efficiency of partial behavioral reflection. First, we propose unanticipated partial behavioral reflection which enables the developer to precisely select the required reifications, to flexibly engineer the metalevel and to introduce the meta behavior dynamically. Second, we present a system supporting unanticipated partial behavioral reflection in Squeak Smalltalk, called Geppetto, and illustrate its use with a concrete example of a web application. Benchmarks validate the applicability of our proposal as an extension to the standard reflective abilities of Smalltalk.

Test Blueprints - Exposing Side Effects in Execution Traces to Support Writing Unit Tests

Writing unit tests for legacy systems is a key maintenance task. When writing tests for object-oriented programs, objects need to be set up and the expected effects of executing the unit under test need to be verified. If developers lack internal knowledge of a system, the task of writing tests is non-trivial. To address this problem, we propose an approach that exposes side effects detected in example runs of the system and uses these side effects to guide the developer when writing tests. We introduce a visualization called Test Blueprint, through which we identify what the required fixture is and what assertions are needed to verify the correct behavior of a unit under test. The dynamic analysis technique that underlies our approach is based on both tracing method executions and on tracking the flow of objects at runtime. To demonstrate the usefulness of our approach we present results from two case studies.

Exploiting Runtime Information in the IDE

Developers rely on the mechanisms provided by their IDE to browse and navigate a large software system. These mechanisms are usually based purely on a system's static source code. The static perspective, however, is not enough to understand an object-oriented program's behavior, in particular if implemented in a dynamic language. We propose to enhance IDEs with a program's runtime information (eg. message sends and type information) to support program comprehension through precise navigation and informative browsing. To precisely specify the type and amount of runtime data to gather about a system under development, dynamically and on demand, we adopt a technique known as partial behavioral reflection. We implemented navigation and browsing enhancements to an IDE that exploit this runtime information in a prototype called Hermion. We present preliminary validation of our experimental enhanced IDE by asking developers to assess its usefulness to understand an unfamiliar software system.

FAME, A Polyglot Library for Metamodeling at Runtime

Tomorrow's eternal software system will co-evolve with their context: their metamodels must adapt at runtime to ever-changing external requirements. In this paper we present FAME, a polyglot library that keeps metamodels accessible and adaptable at runtime. Special care is taken to establish causal connection between fame-classes and host-classes. As some host-languages offer limited reflection features only, not all implementations feature the same degree of causal connection. We present and discuss three scenarios: 1) full causal connection, 2) no causal connection, and 3) emulated causal connection. Of which, both Scenario 1 and 3 are suitable to deploy fully metamodel-driven applications.

Querying Runtime Information in the IDE

Code queries focus mainly on the static structure of a system. To comprehend the dynamic behavior of a system however, a software engineer needs to be able to reason about the dynamics of this system, for instance by querying a database of dynamic information. Such a querying mechanism should be directly available in the IDE where the developers implements, navigates and reasons about the software system. We propose (i) concepts to gather dynamic information, (ii) the means to query this information, and (iii) tools and techniques to integrate querying of dynamic information in the IDE, including the presentation of results generated by queries.

Pinocchio: Bringing Reflection to Life with First-Class Interpreters

To support development tools like debuggers, runtime systems need to provide a meta-programming interface to alter their semantics and access internal data. Reflective capabilities are typically fixed by the Virtual Machine (VM). Unanticipated reflective features must either be simulated by complex program transformations, or they require the development of a specially tailored VM. We propose a novel approach to behavioral reflection that eliminates the barrier between applications and the VM by manipulating an explicit tower of first-class interpreters. Pinocchio is a proof-of-concept implementation of our approach which enables radical changes to the interpretation of programs by explicitly instantiating subclasses of the base interpreter. We illustrate the design of Pinocchio through non-trivial examples that extend runtime semantics to support debugging, parallel debugging, and back-in-time object-flow debugging. Although performance is not yet addressed, we also discuss numerous opportunities for optimization, which we believe will lead to a practical approach to behavioral reflection.

Analyzing Software Evolution through Feature Views

Features encapsulate the domain knowledge of a software system and thus are valuable sources of information for a reverse engineer. When analyzing the evolution of a system, we need to know how and which features were modified to recover both the change intention and its extent, namely which source artifacts are affected. Typically, the implementation of a feature crosscuts a number of source artifacts. To obtain a mapping between features to the source artifacts, we exercise the features and capture their execution traces. However this results in large traces that are difficult to interpret. To tackle this issue we compact the traces into simple sets of source artifacts that participate in a feature's runtime behavior. We refer to these compacted traces as feature views. Within a feature view, we partition the source artifacts into disjoint sets of characterized software entities. The characterization defines the level of participation of a source entity in the features. We then analyze the features over several versions of a system and we plot their evolution to reveal how and hich features were affected by changes in the code. We show the usefulness of our approach by applying it to a case study where we address the problem of merging parallel development tracks of the same system.

Transformation of local medicinal knowledge in the Andean Highlands: Case studies from Peru and Bolivia

In the Andean highlands, indigenous environmental knowledge is currently undergoing major changes as a result of various external and internal factors. As in other parts of the world, an overall process of erosion of local knowledge can be observed. In response to this trend, some initiatives that adopt a biocultural approach aim at actively strengthening local identities and revalorizing indigenous environmental knowledge and practices, assuming that such practices can contribute to more sustainable management of biodiversity. However, these initiatives usually lack a sound research basis, as few studies have focused on the dynamics of indigenous environmental knowledge in the Andes and on its links with biodiversity management. Against this background, the general objective of this research project was to contribute to the understanding of the dynamics of indigenous environmental knowledge in the Andean highlands of Peru and Bolivia by investigating how local medicinal knowledge is socially differentiated within rural communities, how it is transformed, and which external and internal factors influence these transformation processes. The project adopted an actor-oriented perspective and emphasized the concept of knowledge dialogue by analyzing the integration of traditional and formal medicinal systems within family therapeutic strategies. It also aimed at grasping some of the links between the dynamics of medicinal knowledge and the types of land use systems and biodiversity management. Research was conducted in two case study areas of the Andes, both Quechua-speaking and situated in comparable agro-ecological production belts - Pitumarca District, Department of Cusco (Southern Peruvian Highlands) and the Tunari National Park, Department of Cochabamba (Bolivian inner-Andean valleys). In each case study area, the land use systems and strategies of 18 families from two rural communities, their environmental knowledge related to medicine and to the local therapeutic flora, and an appreciation of the dynamics of this knowledge were assessed. Data were collected through a combination of disciplinary and participatory action-research methods. It was mostly analyzed using qualitative methods, though some quantitative ethnobotanical methods were also used. In both case studies, traditional medicine still constitutes the preferred option for the families interviewed, independently of their age, education level, economic status, religion, or migration status. Surprisingly and contrary to general assertions among local NGOs and researchers, results show that there is a revival of Andean medicine within the younger generation, who have greater knowledge of medicinal plants than the previous one, value this knowledge as an important element of their way of life and relationship with “Mother Earth” (Pachamama), and, at least in the Bolivian case, prefer to consult the traditional healer rather than go to the health post. Migration to the urban centres and the Amazon lowlands, commonly thought to be an important factor of local medicinal knowledge loss, only affects people’s knowledge in the case of families who migrate over half of the year or permanently. Migration does not influence the knowledge of medicinal plants or the therapeutic strategies of families who migrate temporarily for shorter periods of time. Finally, economic status influences neither the status of people’s medicinal knowledge, nor families’ therapeutic strategies, even though the financial factor is often mentioned by practitioners and local people as the main reason for not using the formal health system. The influence of the formal health system on traditional medicinal knowledge varies in each case study area. In the Bolivian case, where it was only introduced in the 1990s and access to it is still very limited, the main impact was to give local communities access to contraceptive methods and to vaccination. In the Peruvian case, the formal system had a much greater impact on families’ health practices, due to local and national policies that, for instance, practically prohibit some traditional practices such as home birth. But in both cases, biomedicine is not considered capable of responding to cultural illnesses such as “fear” (susto), “bad air” (malviento), or “anger” (colerina). As a consequence, Andean farmers integrate the traditional medicinal system and the formal one within their multiple therapeutic strategies, reflecting an inter-ontological dialogue between different conceptions of health and illness. These findings reflect a more general trend in the Andes, where indigenous communities are currently actively revalorizing their knowledge and taking up traditional practices, thus strengthening their indigenous collective identities in a process of cultural resistance.

Model-Centric, Context-Aware Software Adaptation

Software must be constantly adapted to changing requirements. The time scale, abstraction level and granularity of adaptations may vary from short-term, fine-grained adaptation to long-term, coarse-grained evolution. Fine-grained, dynamic and context-dependent adaptations can be particularly difficult to realize in long-lived, large-scale software systems. We argue that, in order to effectively and efficiently deploy such changes, adaptive applications must be built on an infrastructure that is not just model-driven, but is both model-centric and context-aware. Specifically, this means that high-level, causally-connected models of the application and the software infrastructure itself should be available at run-time, and that changes may need to be scoped to the run-time execution context. We first review the dimensions of software adaptation and evolution, and then we show how model-centric design can address the adaptation needs of a variety of applications that span these dimensions. We demonstrate through concrete examples how model-centric and context-aware designs work at the level of application interface, programming language and runtime. We then propose a research agenda for a model-centric development environment that supports dynamic software adaptation and evolution.