Maja D'Hondt

Detecting and resolving model inconsistencies using transformation dependency analysis

Model inconsistency management is a crucial aspect of model-driven software engineering. It is therefore important to provide automated support for this activity. The problem is, however, that the resolution of inconsistencies may give rise to new inconsistencies. To address this problem, we propose to express inconsistency detection and resolutions as graph transformation rules, and to apply the theory of critical pair analysis to analyse potential dependencies between the detection and resolution of model inconsistencies. As a proof-of-concept, we report on an experiment that we have carried out along these lines using the critical pair analysis algorithm implemented in the state-of-the-art graph transformation tool AGG. The results show that both anticipated and unexpected dependencies between inconsistency detection and resolution rules are found by AGG. We discuss how the integration of the proposed approach into contemporary modelling tools may improve inconsistency management in various ways.

Hybrid aspects for weaving object-oriented functionality and rule-based knowledge

Software applications often consist of implicit knowledge for making decisions or giving advice in addition to object-oriented functionality. A rule-based system can be employed for representing and reasoning with this knowledge. Although several hybrid systems exist that combine object-oriented programming and rule-based reasoning, a survey we conducted reveals that both paradigms are not well integrated and programs are tightly coupled.We propose hybrid aspects for integrating object-oriented programming and rule-based reasoning. As expected, hybrid aspects specify join points where normal execution is interrupted and advice is executed. However, since two different languages are involved, we need join point models for both and advice that activates both. As such, we complement a simple join point model for object-oriented programming with a join point model for rule-based reasoning. Hybrid advice is independent of the interrupted language and supports sending messages as well as activating rules. It uses values of either language transparently.We present OReA, an implementation of hybrid aspects for weaving Smalltalk and a rule-based system. We discuss and illustrate two applications of hybrid aspects.

An Extension to Fuzzy Cognitive Maps for Classification and Prediction

Fuzzy cognitive maps (FCMs), as an illustrative causative representation of modeling and manipulation of complex systems, can be used to model the dynamic behavior of the investigated systems. However, due to defects in expression and architecture, the traditional FCMs and most of their relevant extensions are not applicable to classification problems. To solve this problem, this paper presents an approach that directly extends the model by translating the reasoning mechanism of traditional FCMs to a set of fuzzy IF-THEN rules. Moreover, the proposed approach fully considers the contribution of the inputs to the activation of the fuzzy rules and quantifies the causalities using mutual subsethood, which works in conjunction with volume defuzziflcation in a gradient descent-learning framework. In this manner, our approach enhances the capability of the conventional FCMs to automatically identify membership functions and quantify causalities. Despite the increase in the number of tunable parameters, experimental results show that the proposed approach efficiently extends the application of the traditional FCMs into classification problems, while keeping the ability for prediction and approximation.

Feature Interaction in Composed Systems

The history of computer science has shown that decomposing software applications helps managing their complexity and facilitates reuse, but also bears challenging problems still unsolved, such as the assembly of the decomposed features when non-trivial feature interactions are involved. Examples of features include concerns or aspects, black box or white box components, and functional and non-functional requirements. Approaches such as object-oriented and component-based software development, as well as relatively new directions such as aspect-oriented programming, multi-dimensional separation of concerns and generative programming, all provide technical support for the definition and syntactical assembly of features, but fall short on the semantic level, for example in spotting meaningless or even faulty combinations. At previous ECOOPs, OOPSLAsand GCSEs dedicated events have been organised around the aforementioned technologies, where we experienced a growing awareness of this feature interaction problem. However, feature interaction is often merely dismissed as a secondary problem, percolating as an afterthought while other issues are being addressed. The intention of this workshop was to be the first co-ordinated effort to address the general problem of feature interaction in composed systems separately from other issues.

Model refactorings through rule-based inconsistency resolution

The goal of model-driven engineering is to raise the level of abstraction by shifting the focus to models. As a result, complex software development activities move to the modelling level as well. One such activity is model refactoring, a technique for restructuring the models in order to improve some quality attributes of the models. As a first contribution of this paper, we argue and show that refactoring a model is enabled by inconsistency detection and resolution. Inconsistencies in or between models occur since models typically describe a software system from different viewpoints and on different levels of abstraction. A second contribution of this paper is rule-based inconsistency resolution, which enables reuse of different inconsistency resolutions across model refactorings and manages the flow of inconsistency resolution steps automatically.

Seamless integration of rule-based knowledge and object-oriented functionality with linguistic symbiosis

Software applications often contain implicit knowledge in addition to functionality which is inherently object-oriented. Many approaches and systems exist that focus on separating rule-based knowledge from object-oriented functionality and representing it explicitly in a logic reasoning system. Support for seamless integration of this knowledge with the object-oriented functionality improves software development and evolution. Our hypothesis is that a linguistic symbiosis is required between the logic reasoning and object-oriented programming paradigms in order to achieve seamless integration.This paper presents a symbiotic extension of SOUL, a system which implements a logic programming language and a production system in Smalltalk. The presence of these two logic reasoning systems in SOUL ensures a comprehensive coverage of rule-based reasoning styles, more specifically forward and backward chaining. Our approach is evaluated by means of two case studies. We summarise a comprehensive survey, which shows that existing systems do not fully support seamless integration.

Inter-language reflection: A conceptual model and its implementation

Meta programming is the act of reasoning about a computational system. For example, a program in Prolog can reason about a program written in Smalltalk. Reflection is a more powerful form of meta programming where the same language is used to reason about, and act upon, itself in a causally connected way. Thus on the one hand we have meta programming that allows different languages or paradigms to be used, but without causal connection, while on the other hand we have reflection that offers causal connection but only for a single language. This paper combines both and presents inter-language reflection that allows one language to reason about and change in a causally connected way another language and vice versa. The fundamental aspects of inter-language reflection and the language symbiosis used therein, are discussed. Moreover the implementation of two symbiotic reflective languages is discussed: Agora/Java and SOUL/Smalltalk.

A probabilistic fuzzy approach to modeling nonlinear systems

Recently, the study of incorporating probability theory and fuzzy logic has received much interest. To endow the traditional fuzzy rule-based systems (FRBs) with probabilistic features to handle randomness, this paper presents a probabilistic fuzzy neural network (ProFNN) by introducing the probability of input linguistic terms and providing linguistic meaning into the connectionist architecture. ProFNN integrates the probabilistic information of fuzzy rules into the antecedent parts and quantifies the impacts of the rules on the consequent parts using mutual subsethood, which work in conjunction with volume defuzzification in a gradient descent learning frame work. Despite the increase in the number of parameters, ProFNN provides a promising solution to deal with randomness and fuzziness in a single frame. To evaluate the performance and applicability of the proposed approach, ProFNN is carried out on various benchmarking problems and compared with other existing models with a performance better than most of them.

A slice of MDE with AOP: transforming high-level business rules to aspects

We propose an approach that combines MDE and AOSD to automatically translate high-level business rules to aspects and integrate them with existing object-oriented applications. The separation of rule-based knowledge from the core application as explicit business rules has been the focus of existing approaches. However, they fail at supporting rules that are both high-level, i.e. defined in domain terms, and operational, i.e. automatically executable from the core application. In this paper we propose high-level languages for expressing business rules at the domain level as well as their connections to the core application. We provide support for automatically translating high-level rules to object-oriented programs and their connections to aspects, since these crosscut the core application. Separation of concerns is preserved at the domain and implementation levels, facilitating traceability, reusability and adaptability. A prototype implementation and a discussion on trade-offs are presented.

Ensuring quality of geographic data with UML and OCL

Geographic data is the backbone of sophisticated applications such as car navigation systems and Geographic Information Systems (GIS). Complexity quickly arises in the production of geographic data when trying to ensure quality. We define quality as the integrity and well-formedness of the contents of the geographic data, usually enforced by external applications where constraints ensuring quality (referred to as quality constraints) are implicit, low-level and scattered throughout the application code. This has significant consequences with respect to manageability, adaptability and reuse of these constraints. This paper explains our use of UML class diagrams as conceptual model for geographic data, and how we exploited the Object Constraint Language (OCL) for describing the quality constraints in an explicit, declarative and high-level way. As our use of OCL is slightly different than it was originally intended, we present our adaptations and explain the main issues of evaluating the resulting OCL. We are confident that our specific application of OCL can be put to use in other domains where complex constraints need to be expressed in a knowledge-oriented domain.