Introducing Context-Awareness in Applications by Transforming High-Level Rules

International audienceIn the last years, we have witnessed the increase in the popu- larity and capabilities of mobile technologies. This evolution has enforced the idea of smart environments, in which devices are aware and able to react to changes in their environment. In this position paper we describe a specific approach for the development of context-aware software. We propose to make existing applications context-aware by means of three main components: context models, high-level rules and code-generation processors. We present each component and analyze the issues related to the development of context-aware software following this strategy

Context Distribution for Supporting Composition of Applications in Ubiquitous Computing

Poster PaperInternational audienceFor context-aware devices and applications to be able to interact both with each other and their environment, mechanisms are required to allow these to react to changes in the environment. Furthermore, individual applications participating in a context must work together in an integrated and coherent manner. To address this concern, we have designed and implemented CARBO, a generative, rule based centralized orchestration engine. However, in ubiquitous computing, context is distributed amongst different participants. In this paper we describe how we extended CARBO with the notion of context slices, which distribute the context state amongst different devices. We also discuss the use of tagged futures as an implementation strategy. This simplifies the work needed to synchronize context instances across devices, which eases the maintenance of context consistency

Declarative Metaprogramming to Support Reuse in Vertical Markets

To eliminate the di#culties caused by the implicit nature of the natural relationship between domain models (and the corresponding delta-analyses) and framework instances, we aim to provide a mechanism for the construction of a bidirectional, concrete, active link between domain models and framework code by constructing a new instance of declarative metaprogramming. This instance supports a symbiosis between a prototype-based, framebased knowledge representation language and an object-oriented programming language. This implies that framework code in the object-oriented language co-evolves with the corresponding knowledge representation

DEUCE : Separating Concerns in User Interfaces

Abstract—As current software systems evolve continuously, both the application and its user interface (UI) have to be adapted. However, UI code is often scattered through and entangled with the application code. In large and complex UIs, this tangling renders the implementation complex and hard to maintain. At this time, the application needs to perform both the necessary changes to the UI (e.g. disabling other buttons, propagating events, etc.) as well as invoke the required appli-cation logic. The Deuce framework (Declarative User Interface Concerns Extrication) intends to reduce the complexity of UI implementations by applying separation of concerns on three UI concerns: presentation logic, business and data logic, and connection logic. It does so by using a declarative meta-language (SOUL) on top of an object oriented language (Smalltalk) such that an adequate language is provided to describe the entire structure and behavior of the UI, as well as linking it with the application. I

SelfSync: A Dynamic Round-Trip Engineering Environment

Abstract. Model-Driven Engineering (MDE) advocates the generation of software applications from models, which are views on certain aspects of the software. In this paper, we focus on a particular setup which consists of a graphical data modeling view and a view on an object-oriented implementation, which can be either textual or graphical. A challenge that arizes in the context of MDE is the notion of Round-Trip Engineering (RTE), where elements from both views can be manipulated and thus need to be synchronized. We systematically identify four fundamental RTE scenarios. In this paper, we employ the framework of these scenarios for explaining SelfSync, our approach and tool for providing dynamic support for RTE. In SelfSync, the entities of the data modeling view and the corresponding implementation objects are one and the same. Additionally, we present a comparison with related work accompanied by an extensive discussion.

Rapid Prototyping of Extended Entity-Relationship Models

Abstract: The entity-relationship model is considered to be the standard for conceptual design of data in information systems and relational databases. Extended entity-relationship models provide extra concepts such as generalization, dependency and classification. In the context of objectoriented software development, such models are able to represent part of the functionality whereas more operational functionality is implemented in the object-oriented language. In the resulting object-oriented program, however, the original data model is often lost and the relationship and dependency constraints are not enforced. We propose an approach which consists of an active modeling phase and an interactive prototyping phase. The overall result is a model in which the elements have active links to fully operational implementation objects, which in turn are actively constrained by the model. We have developed a system that supports the manual steps in these two phases and fully implements the (semi-)automatic steps

SelfSync: A Dynamic Round-Trip Engineering Environment

Abstract. Model-Driven Engineering (MDE) advocates the generation of software applications from models, which are views on certain aspects of the software. In order to minimize the delta between these views we propose a highly dynamic Round-Trip Engineering (RTE) technique where the elements of the various views are one and the same. We combine Extended Entity-Relationship diagrams with an object-oriented prototype-based language in a two-phased technique that allows for the rapid prototyping of the modeled applications. Run-time objects are included in the RTE process resulting in advanced constraint enforcement. Moreover support is provided for straightforward role modeling.

Domain Modeling in Self Yields Warped Hierarchies

Domain modeling can result in a hierarchical set-up in which the modeled entities follow the standard hierarchical taxonomies while the proper execution of the corresponding code demands the reversed hierarchy. Modeling roles and the identity problem are typical cases of these ”warped ” hierarchies, which are difficult to implement in classbased languages. In the prototype-based language Self, entities are modeled into hierarchies of traits, supporting multiple inheritance, dynamic parent sharing and copy-down techniques. This powerful cocktail of features allows building warped hierarchies in a straightforward and natural manner