An IDE to Build and Check Task Flow Models

This paper presents the Eclipse plug-ins for the Task Flow model in the Discovery Method. These plug-ins provide an IDE for the Task Algebra compiler and the model-checking tools. The Task Algebra is the formal representation for the Task Model and it is based on simple and compound tasks. The model-checking techniques were developed to validate Task Models represented in the algebra.

💡 Research Summary

The paper presents a comprehensive Eclipse‑based integrated development environment (IDE) that supports the entire lifecycle of Task Flow models defined in the Discovery Method, from graphical modeling to formal verification. Central to the approach is the definition of a dedicated Task Algebra, which serves as a formal semantics for Task Flow diagrams. The algebra includes the empty activity (ε), success (σ), failure (ϕ), and operators for sequential composition (;), choice (+), parallel composition (k), and recursion (µ). Unlike traditional process algebras that treat actions as atomic, Task Algebra models tasks as intervals, reflecting the non‑atomic nature of business activities in the Discovery Method.

The IDE is built on Eclipse’s Plug‑in Development Environment (PDE), the Eclipse Modeling Framework (EMF), and the Graphical Modeling Framework (GMF). A structured meta‑model describing Task Flow elements (Task, Fork, Join, Exception, etc.) is first defined in EMF. GMF then automatically generates a graphical editor where users can drag‑and‑drop diagram elements, creating Task Flow models visually. Upon saving, the editor translates the diagram into a Task Algebra expression, which is fed to a trace‑semantics generator. This generator produces the complete set of execution traces (paths) that the model can follow.

Verification is performed using two temporal logics: Linear Temporal Logic (LTL) and Computation Tree Logic (CTL). The trace set is directly evaluated against LTL formulas, allowing statements such as “whenever task A succeeds, task B eventually occurs” to be checked over all linear paths. For CTL, the traces are first organized into a tree structure so that path‑quantified properties (e.g., “there exists a path where an error inevitably occurs”) can be assessed. The verification results are displayed in Eclipse views, highlighting successful or failing traces and providing visual feedback that links back to the original diagram.

To aid users in writing temporal‑logic queries, the authors integrate an Xtext‑based domain‑specific language (DSL) editor. This editor offers syntax highlighting, auto‑completion, and error checking for LTL/CTL expressions, lowering the barrier for non‑expert users. The overall architecture consists of three loosely coupled plug‑ins: (1) the modeling plug‑in (graphical editor and meta‑model), (2) the compiler plug‑in (Task Algebra parser and trace generator), and (3) the verification plug‑in (LTL/CTL engines and result visualizer). Because each plug‑in uses Eclipse extension points, new operators, additional logics, or alternative back‑ends can be added without redesigning the whole system.

The authors report that roughly half of the intended functionality has been implemented and demonstrated. The prototype successfully carries out the full pipeline: diagram creation → algebraic translation → trace generation → LTL verification. The model‑driven approach dramatically reduces the amount of hand‑written code; changes to the meta‑model automatically propagate to the editor and verification components.

Nevertheless, the current implementation has limitations. The algebra supports only basic constructs (sequence, choice, parallel, loops), which may be insufficient for modeling complex asynchronous workflows, real‑time constraints, or priority‑based execution. Moreover, the trace generation can suffer from state‑space explosion for large models, and the paper does not present any state‑compression or partial‑verification techniques. Future work is suggested to extend the algebra with richer operators (timeouts, priorities), incorporate abstraction or symbolic techniques to mitigate trace explosion, and explore timed extensions to handle real‑time systems.

In summary, the paper delivers a practical, Eclipse‑integrated solution that bridges visual Task Flow modeling with formal verification using Task Algebra, LTL, and CTL. By embedding verification directly into the modeling environment, it enables early detection of design errors and promotes the adoption of formal methods in everyday software engineering practice.