Organizations rely on the logic embedded in their Information Systems for their daily operations. This logic implements the business rules in place in the organization, which must be continuously adapted in response to market changes. Unfortunately, this evolution implies understanding and evolving also the underlying software components enforcing those rules. This is challenging because, first, the code implementing the rules is scattered throughout the whole system and, second, most of the time documentation is poor and out-of-date. This is specially true for older systems that have been maintained and evolved for several years (even decades). In those systems, it is not even clear which business rules are enforced nor whether rules are still consistent with the current organizational policies. In this sense, the goal of this paper is to facilitate the comprehension of legacy systems (in particular COBOL-based ones) by providing a model driven reverse engineering framework able to extract and visualize the business logic embedded in them.

Les entreprises s'appuient sur la logique metier encodee dans leurs systemes d'information. Ce sont souvent des applications existantes qui ne sont pas concues pour representer et operationnaliser cette logique independamment des aspects techniques. Par consequent, ces systemes ne sont pas capables de repondre rapidement aux nouvelles exigences requises par le marche. La decouverte et la gestion de la logique metier dans les applications sont des activites qui consomment beaucoup de temps et qui sont sources d'erreurs, car a chaque fois le code doit etre analyse, modifie et teste. Afin de simplifier ces activites, ce papier propose un framework dirige par les modeles pour l'extraction de la logique m etier. L'Ingenierie Dirigee par les Modeles est utilisee pour decouvrir et representer la logique extraite en fournissant des artefacts en sortie qui aident a sa comprehension.

In order to react to the ever-changing market, every organization needs to periodically reevaluate and evolve its company policies. These policies must be enforced by its Information System (IS) by means of a set of business rules that drive the system behavior and data. Clearly, policies and rules must be aligned at all times but unfortunately this is a challenging task. In most ISs implementation of business rules is scattered among the code so appropriate techniques must be provided for the discovery and evolution of evolving business rules. In this paper we describe a model driven reverse engineering framework aiming at extracting business rules out of Java source code. The use of modeling techniques facilitate the representation of the rules at a higher-abstraction level which enables stakeholders to understand and manipulate them.

In this paper we present an application of pharmaceutical validation of medication based on an OWL ontology and business rules or more specifically clinical decision rules. This application has been developed based on a prototype that enables business users to author, execute and manage their Business Rules over OWL Ontology. This prototype is based on the Business Rule Management System (BRMS) IBM WebSphere ILOG JRules.

In this demonstration we will show two prototypes based on the BRMS (Business Rule Management System) WODM, (1) The OWL plug-in and (2) the change-management plug-in. The OWL plugin enables authoring and executing business rules over OWL ontologies. It consists of importing OWL ontologies into WODM and using the all the functionalities offered by this BRMS to author and execute rules. The change-management plug-in enables the evolution of business rules with respect to the ontology changes. This component, implemented basically using an OWL ontology and rules, detects inconsistencies that could be caused by an ontology evolution and proposes solution(s), called repair, to resolve them.

Most of us have experienced configuration issues when installing new software applications. Finding the right configuration is often a challenging task since we need to deal with many dependencies between plug-ins, components, libraries, packages, etc; sometimes even regarding specific versions of the involved artefacts. Right now, most configuration engines are adhoc tools designed for specific configuration scenarios. This makes their reuse in different contexts very difficult.In this paper we report on our experience in following a MDE-based approach to solve configuration problems. In our approach, the configuration problem is represented as a model that abstracts all irrelevant technological details and facilitates the use of generic (constraint) solvers to find optimal solutions. This approach has been applied by an industrial partner to the management of plug-ins in the Eclipse framework, a big issue for all the technology providers that distribute Eclipse-based tools.

La recherche de la bonne configuration est souvent une tâche complexe necessitant la gestion des nombreuses dependances entre plug-ins. D'autant plus que la plupart des moteurs de configuration existants n'ont pas la flexibilite necessaire permettant de s'adapter a differents scenarios. Dans cet article, nous proposons une approche fondee sur l'IDM permettant la resolution de problemes de configuration, en les representant comme des problemes de satisfaction de contraintes. Un de nos partenaires industriels a utilise cette approche pour la gestion des plug-ins dans le cadre d'Eclipse. Cette gestion est consideree comme un probleme important pour tous les fournisseurs de solutions basees sur Eclipse.

The main goal of this workshop is to bring together two different communities: the Model-Driven Engineering (MDE) community and the logic programming community, to explore how each community can benefit from the techniques of the other. Are both communities friends or foes?

This paper describes an approach in the double context of business rules and techniques of the semantic web, the ontologies. This approach consists of enabling the use of business rules to automate the decisions on domains which semantic is formalized with an ontological language. Our main objective is to enable business users to edit, manage and execute business rules grounded in ontologies without resorting to an expert. The implementation is based on the Business Rule Management System (BRMS) IBM WebSphere ILOG JRules.

We introduce an approach which combines ACO (Ant Colony Optimization) and IBM ILOG CP Optimizer for solving COPs (Combinatorial Optimization Problems). The problem is modeled using the CP Optimizer modeling API. Then, it is solved in a generic way by a two-phase algorithm. The first phase aims at creating a hot start for the second: it samples the solution space and applies reinforcement learning techniques as implemented in ACO to create pheromone trails. During the second phase, CP Optimizer performs a complete tree search guided by the pheromone trails previously accumulated. The first experimental results on knapsack, quadratic assignment and maximum independent set problems show that this new algorithm enhances the performance of CP Optimizer alone.

Model Driven Engineering (MDE) and constraint programming (CP) have been widely used and combined in different applications. However, existing results are either ad-hoc, not fully integrated or manually executed. In this article, we present a formalization and an approach for automating constraint-based solving in a MDE platform. Our approach generalizes existing work by combining known MDE concepts with CP techniques into a single operation called model search. We present the theoretical basis for model search, as well as an automated process that details the involved operations. We validate our approach by comparing two implemented solutions (one based on Alloy/SAT, the other on OPL/CP), and by executing them over an academic use-case.

Complex software systems are often constructed by assembling bundles from repositories. Eclipse is one of these systems; build on top of a platform accepting different sets of bundles according to the user needs. This adaptability is one of the main benefits of this kind of systems but implies also several configuration problems. The consistency of Eclipse plug‐in's bundles is one of them. This problem involves a need for the configuration validation. To adress this problem, this paper proposes an approach using model driven engineering. The presented solution combines different MDE techniques such as global model management and model transformations to check the coherency of Eclipse plug‐in's bundles.

Model Driven Engineering (MDE) is rapidly maturing and is being deployed in several situations. We report here on an experiment conducted in the context of ILOG, a leader in the development of Business Rule Management Systems (BRMS). BRMSs aim at enabling business users automating their business policies. There is a growing number of BRMS supporting different languages, but also a lack of tools for bridging them. In this paper, we present an approach based on MDE techniques for bridging rule languages; the solution has been fully implemented and tested on different BRMS. The success of the experiment has led to the development and chaining of a significant number of model transformations – no less than twenty. At the same time, this deployment has shown new problems arising from the management of a high number of artifacts. We discuss the positive assessment of MDE in this field, but also the need to address the complexity generated.

Nous introduisons deux approches reactives pour adapter dynamiquement certains parametres d'un algorithme base sur l'optimisation par colonies de fourmis. Les deux approches utilisent l'optimisation par colonie de fourmis pour adapter les parametres : des traces de pheromone sont associees aux valeurs des parametres ; ces traces representent l'experience de la colonie concernant l'utilisation de ces valeurs et sont utilisees pour affecter des valeurs aux parametres de facon probabiliste. Les deux approches different dans la granularite de l'apprentissage. On evalue experimentalement ces deux approches sur un algorithme par colonies de fourmis dedie a la resolution de problemes de satisfaction de contraintes.

Les schemas conceptuels (SC) sont des elements centraux des systemes d’information. Dans un processus d’administration, un probleme recurrent et difficile est de permettre aux decideurs de directement definir et maintenir leurs schemas a l’aide d’un langage pseudonaturel. Semantics for Business Vocabulary and Rules (SBVR), une specification recemment publiee, offre une syntaxe abstraite permettant d’exprimer un SC et une syntaxe concrete a base d’Anglais structure. Dans cet article, nous proposons une methode originale pour extraire un modele SBVR a partir d’un texte anglais puis le transformer en un diagramme de classe UML. Nous decrivons, dans un cadre d’ingenierie des modeles, une combinaison de programmation par contraintes orientee objet et de transformation de modeles. En plus des resultats theoriques, des experimentations preliminaires sont fournies sur un exemple concret.