Hanh Nhi Tran

Modeling Process Patterns and Their Application

Process pattern is an emerging approach for process reuse. Representing process models based on process patterns to explicit process solutions and factor recurrent process constituents is useful for process understanding as well as process modeling. This subject, however, is still a challenge for the software process technology community. In this paper, we present a UML-based process meta-model that allows explicit representation of process patterns in process models. The novel of our proposition is to enable the application of different process knowledge kinds not only for building but also for improving process models.

Rule-Level Verification of Graph Transformations for Invariants Based on Edges' Transitive Closure

This paper develops methods to reason about graph transformation rules for proving the preservation of structural properties, especially global properties on reachability. We characterize a graph transformation rule with an applicability condition specifying the matching conditions of the rule on a host graph as well as the properties to be preserved during the transformation. Our previous work has demonstrated the possibility to reason about a graph transformation at rulelevel with applicability conditions restricted to Boolean combinations of edge expressions. We now extend the approach to handle the applicability conditions containing transitive closure of edges, which implicitly refer to an unbounded number of nodes. We show how these can be internalized into a finite pattern graph in order to enable verification of global properties on paths instead of local properties on edges only.

Towards a Rule-Level Verification Framework for Property-Preserving Graph Transformations

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.

Towards a change-aware process environment for system and software process

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.

Impact Analysis of Process Change at Run-Time

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.

An Approach to Define and Apply Collaboration Process Patterns for Software Development

Complex system developments are more and more collaborative. Collaboration strategies largely depend on the development context at modelling, instantiation or enactment time. To put collaboration in action, we propose collaboration process patterns to define, reuse and enact collaborative software development processes. In this paper we describe the definition and application of collaboration patterns. Our patterns, inspired from workflow patterns of Van der Aalst, are described in CMSPEM, a Process Modelling Language developed in our team in 2014. In this paper, we briefly describe the CMSPEM metamodel and focus our presentation on two collaboration patterns: Duplicate in Sequence with Multiple Actors, Duplicate in Parallel with Multiple Actors and Merge. The approach is illustrated by a case study concerning the collaborative and representative process “Review a deliverable”.

Defining and using collaboration patterns for software process development

Collaboration patterns are an efficient way to define, reuse and enact collaborative software development processes. We propose an approach to define and apply collaboration patterns at modelling, instantiation or execution time. Our patterns, inspired from workflow patterns, are described in CMSPEM, a Process Modelling Language developed in our team. In this paper, we briefly describe the CMSPEM metamodel and focus our presentation on two collaboration patterns: Duplicate in Sequence with Multiple Actors, Duplicate in Parallel with Multiple Actors and Merge. The approach is illustrated by a case study concerning the collaborative process “Review a deliverable”.

Attribute Computations in the DPoPb Graph Transformation Engine

One of the challenges of attributed graph rewriting systems concerns the implementation of attribute computations. Most of the existing systems adopt the standard algebraic approach where graphs are attributed using sigma-algebras. However, for the sake of efficiency considerations and convenient uses, these systems do not generally implement the whole attribute computations but rely on programs written in a host language. In previous works we introduced the Double Pushout Pullback (DPoPb) framework which integrates attributed graph rewriting and computation on attributes in a unified categorical approach. This paper discusses the DPoPb’s theoretical and practical advantages when using inductive types and lambda-calculus. We also present an implementation of the DPoPb system in the Haskell language which thoroughly covers the semantics of this graph rewriting system.

Combining Dynamic and Static Analysis to Help Develop Correct Graph Transformations

Developing provably correct graph transformations is not a trivial task. Besides writing the code, a developer must as well specify the pre- and post-conditions. The objective of our work is to assist developers in producing such a Hoare triple in order to submit it to a formal verification tool. By combining static and dynamic analysis, we aim at providing more useful feedback to developers. Dynamic analysis helps identify inconsistencies between the code and its specifications. Static analysis facilitates extracting the pre- and post-conditions from the code. Based on this proposal, we implemented a prototype that allows running, testing and proving graph transformations written in small-\( \text{t}_{\mathcal{ALC}} \), our own transformation language.

Towards a Tool-Supported Approach for Collaborative Process Modeling and Enactment

In software engineering, as in any collective endeavor, understanding and supporting collaboration is a major concern. Unfortunately, the main concepts of popular process formalisms are not always adequate to describe collaboration. We extend the Software & System Process Engineering Meta-Model (SPEM) by introducing concepts needed to represent precise and dynamic collaboration setups that practitioners create to address ever-changing challenges. Our goal is to give practitioners the ability to express evolving understanding about collaboration in a formalism suited for easy representation and tool-provided assistance. Our work is based on a collaborative process metamodel we have developed. In this paper, we first present a meta-process for process modeling and enactment, which we apply to our collaborative process metamodel. Then we describe the implementation of a suitable process model editor, and a project plan generator from process models.