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.

Enhancing sealing of fetal membrane defects using tissue engineered native amniotic scaffolds in the rabbit model

OBJECTIVE: The purpose of this study was to compare the efficacy of native engineered amniotic scaffolds (AS) and polyesterurethane scaffolds (DegraPol) and document wound healing response when sealing iatrogenic fetal membrane defects in the rabbit model. STUDY DESIGN: Native AS were engineered from freshly harvested membranes of 23 days' gestational age (GA; term = 31-2 d). Acellularity of AS was assessed by histology, light and scanning electron microscopy. Fetal membrane defects were created by 14 gauge-needle puncture at GA 23 days and primarily closed with AS (n = 10) or DegraPol (n = 10) or left unclosed (positive controls; n = 10). Sixty-one sacs served as negative controls. At GA 30 days a second look hysterotomy was performed to assess presence of amniotic fluid (AF) and harvest plugging sites for microscopic evaluation. RESULTS: Engineered AS had a cell-free collagenous fiber network. AF was significantly higher only in the DegraPol group (78%; P < .05) compared to the AF in positive controls (17%). Integration of plugs in the fetal membrane defect was better with AS than DegraPol, with higher reepithelialization rates (AS: 52.5% +/- 6.5%; DegraPol: 11.6% +/- 2.6%; P < .001) and proliferation indices (AS: 0.47 +/- 0.03; DegraPol: 0.28 +/- 0.04; P = .001). In both treatment groups, cell proliferation in the myometrium was increased (P < .05). CONCLUSION: Native AS seal iatrogenic fetal membrane defects better than DegraPol. Within a week, there is abundant reepithelilization and minimal local inflammation. This yields the proof of principle that engineered native, amniotic membrane scaffolds enhance fetal membrane wound healing response.

Enriching Reverse Engineering with Annotations

Much of the knowledge about software systems is implicit, and therefore difficult to recover by purely automated techniques. Architectural layers and the externally visible features of software systems are two examples of information that can be difficult to detect from source code alone, and that would benefit from additional human knowledge. Typical approaches to reasoning about data involve encoding an explicit meta-model and expressing analyses at that level. Due to its informal nature, however, human knowledge can be difficult to characterize up-front and integrate into such a meta-model. We propose a generic, annotation-based approach to capture such knowledge during the reverse engineering process. Annotation types can be iteratively defined, refined and transformed, without requiring a fixed meta-model to be defined in advance. We show how our approach supports reverse engineering by implementing it in a tool called Metanool and by applying it to (i) analyzing architectural layering, (ii) tracking reengineering tasks, (iii) detecting design flaws, and (iv) analyzing features.

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.

Run-Time Evolution through Explicit Meta-Objects

Software must be constantly adapted due to evolving domain knowledge and unanticipated requirements changes. To adapt a system at run-time we need to reflect on its structure and its behavior. Object-oriented languages introduced reflection to deal with this issue, however, no reflective approach up to now has tried to provide a unified solution to both structural and behavioral reflection. This paper describes Albedo, a unified approach to structural and behavioral reflection. Albedo is a model of fined-grained unanticipated dynamic structural and behavioral adaptation. Instead of providing reflective capabilities as an external mechanism we integrate them deeply in the environment. We show how explicit meta-objects allow us to provide a range of reflective features and thereby evolve both application models and environments at run-time.

Using Smalltalk as a Reflective Executable Meta-Language

Object-oriented meta-languages such as MOF or EMOF are often used to specify domain specific languages. However, these meta-languages lack the ability to describe behavior or operational semantics. Several approaches used a subset of Java mixed with OCL as executable meta-languages. In this paper, we report our experience of using Smalltalk as an executable and integrated meta-language. We validated this approach in incrementally building over the last decade, Moose, a meta-described reengineering environment. The reflective capabilities of Smalltalk support a uniform way of letting the base developer focus on his tasks while at the same time allowing him to meta-describe his domain model. The advantage of our this approach is that the developer uses the same tools and environment