Abstract In System and Software Engineering development, unforeseen changes occurring during process enactment are almost inevitable but often poorly managed due to a lack of efficient mechanisms for spontaneously handling these run‐time changes. We proposed a change‐aware process management system that allows process actors reporting emergent changes, analyzing possible impacts, and notifying people affected by the changes. To this end, we integrated a Change Management Component with a Process Management System. The Process Management System monitors process enactment and uses the run‐time process information to construct a Process dependency graph (PDG) representing the dependencies among the elements of running processes. The Change Management Component captures change requests sent asynchronously, then reasons the PDG to determine impacted elements. Our PDG reflects the information of process instances and therefore can uncover the intra‐process or inter‐processes dependencies that are invisible on process models. We implemented a prototype named CAPE based on the platform jBPM and the graph database Neo4j. Copyright © 2016 John Wiley & Sons, Ltd.

Managing changes for knowledge-intensive processes like System and Software Engineering is a critical issue but far from being mastered due to the lack of supporting methods and practical tools. To manage changes systematically, a process environment is needed to control processes and to handle changes at run-time. However, such an effective environment satisfying these requirements is still missing. The reason is two-folds: first, operational process environments for system and software engineering is scarce; second, there is a lack of efficient change management mechanism integrated in such process environments. In order to address these concerns, we aimed at developing a change-aware process environment for system and software engineering. To this aim, we proposed a change management mechanism based on (1) the Process Dependency Graph (PDG) representing the dependencies among running process instances managed by a process environment ; (2) a Change Observer process to catch change events and update the PDG with run-time information; (3) a Change Analyzer component to extract the impacts of change by reasoning the PDG. In terms of implementation, to gain the benefits from the Business Process Community, where many mature Business Process Management Systems have been developed, we chose jBPM to enact and monitor processes. The key strengths of this study are: first, the PDG makes hidden dependencies among process instances emerge at run-time; second, the process observer inside the BPMS allows to handle the change events in a timely manner. Finally, the Neo4j graph database, used to store the PDG, enables efficient traversal and queries.

In complex domains with features of collaboration and integration, changes taking place in one process may have positive or negative impacts on other collaborative partners and processes. Therefore, supporting changes propagation as well as analysis the impact of changes are desirable functionalities of Business Process Management Systems (BPMSs) and have been investigated in many researches. This paper presents a method to analyze the impacts of process changes at run-time in order to help process practitioners deciding to adopt or not a change. We propose an approach based on Process Dependency Graph (PDG) to represent and monitor the dependencies among running process instances managed by a BPMS. When a change happens, we analyze the PDG graph to deduce the affected process elements and then assess the impact of change by using quantitative metrics extended from the workflow Quality of Service (QoS). Our approach thus provides a generic framework that can be adapted to a specific process domain and a BPMS. The work presented here was validated on some processes in Health-care and Software Development domains with the use of jBPM as a BPMS and Neo4j as a graph database to store and traverse the PDG.

We report in this paper a method for proving that a graph transformation is property-preserving. Our approach uses a relational representation for graph grammar and a logical representation for graph properties with first-order logic formulas. The presented work consists in identifying the general conditions for a graph grammar to preserve graph properties, in particular structural properties. We aim to implement all the relevant notions of graph grammar in the Isabelle/HOL proof assistant in order to allow a (semi) automatic verification of graph transformation with a reasonable complexity. Given an input graph and a set of graph transformation rules, we can use mathematical induction strategies to verify statically if the transformation preserves a particular property of the initial graph. The main highlight of our approach is that such a verification is done without calculating the resulting graph and thus without using a transformation engine.

To ensure the use of good analysis and design practices and an easier maintenance of software, analysts and designers may use patterns. To help them, we propose models inspection in order to detect instantiations of "spoiled pattern" and models reworking through the use of the design patterns. As a design pattern allows the instantiation of the best known solution for a given problem, a "spoiled pattern" allows the instantiation of alternative solutions for the same problem: requirements are respected, but architecture is improvable. We have collected a set of alternative solutions and deduced the corresponding spoiled patterns. We have defined a first catalog of these improvable practices from several experiments with students. To overcome the limits imposed by this method (restricted public, limited problems and tiresome validation process), we would like to open this problematic to the expert community. Therefore, we propose a collaborative website sharing bad practices in object oriented design to improve the use of patterns.

We have defined a direct-execution model dedicated to non-numerical processing which is based upon an internal representation of source programs derived from LISP. This model provides good support for both sophisticated editing (syntactical parsing, tree manipulation, pretty-printing, ...) of conventional languages and artificial intelligence languages. A high level microprogramming language (LEM) was designed to write the interpreters and the editors. A hardware processor was built and a LISP interpreter, microprogrammed in LEM, has been operational since September 1980.

This paper describes the basic principles and the architecture of a general host machine based upon lists processing. Current works in this field are dealing with conventional direct execution schemes which use lineary structured Directly Executable Languages: prefixed languages with varying formats for operators and operands. If these languages are convenient for interpretation and provide an efficient execution scheme, on the other hand, they are very hard to generate.