Process Model Transformation for Event-Based Coordination
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing process modeling technologies face challenges in efficiently coordinating and adapting software applications, particularly in translating process-oriented models into event-based models for runtime adaptation and personalization without requiring significant changes to the original process model.
Innovation Solution
A system that includes a task extractor, analyzer, and object generator to transform process models into event-based coordination models, allowing for deployment into an execution environment where event-based rules and objects coordinate the execution of tasks, enabling runtime adaptation and personalization without altering the original process model.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If process-oriented composite applications are used to aggregate functionality from multiple applications, then coordination and packaging of software applications is achieved, but flexibility for runtime adaptation and personalization is limited
Solution Approach 1:
The process model is segmented into process fragments that can be independently transformed into event-based applications. Each process fragment represents a discrete unit of functionality that can be selectively adapted and personalized at runtime without affecting the entire process model structure.
Solution Approach 2:
An event-based intermediary layer is introduced between the process model and the execution environment. This intermediary transforms process-oriented coordination into event-based coordination, enabling runtime adaptation while preserving the integrity of the original process model.
2Adaptability or versatility
If the process model is modified to add new features or personalization, then adaptability and user customization are improved, but the integrity of the original process model behavior is compromised
Solution Approach 1:
The process model is copied and transformed into an event-based representation. The original process model remains unchanged and serves as the authoritative source, while the copied event-based version allows for runtime modifications, personalization, and adaptations without affecting the original model's integrity.
Solution Approach 2:
The transformation from process model to event-based application is performed in advance, creating a preparatory copy that can be freely adapted. This preliminary transformation action separates the concerns of model definition from model adaptation, allowing runtime changes without compromising the original model.
3Ease of operation
If event-based applications are deployed into middleware, then runtime coordination flexibility is improved, but system complexity increases
Solution Approach 1:
The traditional mechanical process-oriented coordination system is replaced with an event-based coordination system deployed in middleware. This substitution enables more flexible runtime coordination through event-driven mechanisms while the middleware provides a standardized platform that manages the complexity of the event-based architecture.
Data Source
AI summary
A process model specified using, for example, UML activity diagrams can be translated into an event-based model that can be executed on top of a coordination middleware. For example, a process model may be encoded as a collection of coordinating objects that interact with each other through a coordination middleware including a shared memory space. This approach is suitable for undertaking post-deployment adaptation of process-oriented composite applications. In particular, new control dependencies can be encoded by dropping new (or enabling existing) coordinating objects into the space and/or disabling existing ones.