The reviewed record of science sign in
Pith

arxiv: 2606.21416 · v1 · pith:AP37RADG · submitted 2026-06-19 · cs.DC · cs.SE

Bridging Design and Execution: A Visual Graph Editor for Edge and Cloud Workflows

Katarina-Glorija Gruji\'c , Nikola Stankovi\'c , Maja Vukasovi\'c , Milo\v{s} Simi\'c This is my paper

Reviewed by Pith T0 review T1 audit T2 compute T3 formal T4 kernel 2026-06-26 13:02 UTCgrok-4.3pith:AP37RADGrecord.jsonopen to challenge →

classification cs.DC cs.SE
keywords visual graph editoredge computingcloud computingworkflow orchestrationdistributed systemsfederated learningexecution semanticsmodular applications
0
0 comments X

The pith

A visual graph editor with kernels, shared memory nodes, and event triggers bridges design-time modeling and runtime deployment for edge and cloud workflows.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper presents a domain-specific visual graph editor for modular applications in edge and cloud environments. It supports three first-class abstractions: kernels for computation, shared memory nodes for distributed data, and event triggers for dependencies. Users construct graphs visually to define data and control flow, which are then automatically serialized to JSON or XML for an execution API. This approach aims to improve reasoning about data sharing, execution order, and dependencies in distributed scenarios. The editor is demonstrated with a federated learning workflow and claims advantages over traditional tools in explicit semantics and deployability.

Core claim

The central claim is that the graph-based model using kernels, shared memory nodes, and event triggers, combined with visual construction and automatic serialization, bridges the gap between design-time modeling and runtime deployment in distributed edge and cloud scenarios, as shown through the federated learning example.

What carries the argument

The three first-class abstractions—kernels representing computational units, shared memory nodes modeling distributed data, and event triggers capturing execution dependencies—along with visual graph construction and automatic serialization to machine-readable formats.

Load-bearing premise

The three first-class abstractions of kernels, shared memory nodes, and event triggers, together with visual construction and automatic serialization, are sufficient to fully bridge design-time modeling and runtime deployment without needing additional mechanisms.

What would settle it

A real-world distributed edge-cloud application that requires coordination mechanisms or data flows not representable using only kernels, shared memory nodes, and event triggers would falsify the sufficiency claim.

read the original abstract

Designing modular applications for edge and cloud computing environments involves coordinating multiple computational kernels, shared data, and event-driven execution. This paper presents a domain-specific visual graph editor that enables users to model such applications using a unified interface. The editor supports three first-class abstractions: kernels, representing computational units; shared memory nodes, modeling distributed data; and event triggers, capturing execution dependencies. Users can construct graphs visually, configure node properties, and connect elements to define data and control flow. The resulting graphs are automatically serialized into machine-readable representations (JSON/XML) and can be passed to an execution API, bridging the gap between design-time modeling and runtime deployment. The editor's graph-based model improves reasoning about data sharing, execution order, and dependencies, particularly in distributed edge and cloud scenarios. To demonstrate its applicability, we discuss a federated learning workflow, where local training kernels interact with a shared global model through event-driven coordination. Compared to traditional workflow editors and general-purpose diagramming tools, the proposed system provides explicit execution semantics, modularity, and direct deployability. This work lays the foundation for visual orchestration of modular computation in distributed environments and offers extensibility for user-defined kernels, event types, and alternative execution backends, enabling future exploration of complex distributed applications.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The manuscript presents a domain-specific visual graph editor for edge and cloud workflows that uses three first-class abstractions—kernels (computational units), shared memory nodes (distributed data), and event triggers (execution dependencies). Users construct graphs visually to define data and control flow; the graphs are automatically serialized to JSON/XML and passed to an execution API. The paper claims this bridges design-time modeling to runtime deployment, improves reasoning about data sharing and dependencies in distributed settings, and demonstrates applicability via discussion of a federated learning workflow. It positions the system as superior to traditional workflow editors by providing explicit execution semantics, modularity, and direct deployability, with extensibility for custom kernels and backends.

Significance. If the bridging claim holds with the serialized representations sufficient for actual distributed execution, the work could provide a practical contribution to distributed computing by enabling visual orchestration of modular applications with direct deployability. The explicit first-class abstractions for kernels, shared memory, and events offer a structured approach to modularity that general diagramming tools lack, potentially aiding development of edge/cloud systems.

major comments (2)
  1. [Abstract] Abstract: The claim that the editor 'bridges the gap between design-time modeling and runtime deployment' by serializing graphs to JSON/XML for an execution API is load-bearing but unsupported; no details are given on the API specification, the precise JSON/XML schema, or how shared memory nodes encode distributed properties such as consistency, synchronization, or fault handling required for edge/cloud execution.
  2. [Abstract] Abstract (federated learning workflow discussion): The applicability demonstration consists solely of a textual discussion of local training kernels interacting with a shared global model; no execution trace, deployment verification, or evidence that the serialized graph was passed to and executed by the API is provided, leaving the deployability and bridging assertions without empirical grounding.
minor comments (1)
  1. [Abstract] Abstract: The positioning against 'traditional workflow editors and general-purpose diagramming tools' would benefit from a brief feature-comparison table or specific citations to establish the claimed advantages in execution semantics and deployability.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback on our manuscript. The comments highlight areas where additional detail can strengthen the presentation of the bridging claim and the applicability demonstration. We address each point below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: The claim that the editor 'bridges the gap between design-time modeling and runtime deployment' by serializing graphs to JSON/XML for an execution API is load-bearing but unsupported; no details are given on the API specification, the precise JSON/XML schema, or how shared memory nodes encode distributed properties such as consistency, synchronization, or fault handling required for edge/cloud execution.

    Authors: We agree that the bridging claim would be better supported by explicit details on the serialization format. The editor produces a graph model serialized to JSON/XML that captures kernels, shared memory nodes, event triggers, and their connections; the execution API then interprets this model at runtime. Properties such as consistency, synchronization, and fault handling are not encoded in the graph itself but are instead the responsibility of the chosen execution backend. We will revise the manuscript to include the JSON schema (with examples) in an appendix and add a brief clarification of the editor-API separation of concerns. revision: yes

  2. Referee: [Abstract] Abstract (federated learning workflow discussion): The applicability demonstration consists solely of a textual discussion of local training kernels interacting with a shared global model; no execution trace, deployment verification, or evidence that the serialized graph was passed to and executed by the API is provided, leaving the deployability and bridging assertions without empirical grounding.

    Authors: The federated learning discussion is presented as an illustrative application of the abstractions rather than a full empirical evaluation, consistent with the paper's focus on the visual editor design. We acknowledge that this leaves the deployability claim without direct evidence of execution. To address the concern, we will augment the section with a concrete example of the serialized JSON output for the FL workflow, showing how it maps to the API input. This provides a direct link from design to deployment representation without requiring new runtime experiments. revision: partial

Circularity Check

0 steps flagged

No circularity; purely descriptive tool presentation with no derivations

full rationale

The paper describes a visual graph editor using three abstractions (kernels, shared memory nodes, event triggers) and automatic serialization to JSON/XML, claiming this bridges design-time modeling to runtime deployment. No mathematical equations, predictions, fitted parameters, or derivation chains exist. No self-citations, uniqueness theorems, or ansatzes are invoked as load-bearing steps. The central claim is presented as a direct consequence of the implemented features rather than reducing to any input by construction. This matches the default case of a self-contained descriptive paper with no circularity patterns.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 3 invented entities

The paper introduces three modeling abstractions without providing independent evidence or formal definitions beyond the abstract description; no free parameters, mathematical axioms, or falsifiable entities are specified.

invented entities (3)
  • kernels no independent evidence
    purpose: Represent computational units in the workflow graph
    Presented as a first-class abstraction in the editor; no independent evidence supplied.
  • shared memory nodes no independent evidence
    purpose: Model distributed data accessible across kernels
    Presented as a first-class abstraction in the editor; no independent evidence supplied.
  • event triggers no independent evidence
    purpose: Capture execution dependencies and ordering
    Presented as a first-class abstraction in the editor; no independent evidence supplied.

pith-pipeline@v0.9.1-grok · 5778 in / 1322 out tokens · 23406 ms · 2026-06-26T13:02:12.583268+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

25 extracted references · 5 canonical work pages

  1. [1]

    Zhang, X., et al. (2022). Federated learning for edge computing: A survey. Applied Sciences

    2022

  2. [2]

    Hosseinalipour, S., et al. (2020). From Federated to Fog Learning: Distributed ML over Wireless Networks. arXiv:2006.03594

    work page arXiv 2020

  3. [3]

    Satyanarayanan, M. (2017). The emergence of edge computing. Computer, 50(1), 30-39

    2017

  4. [4]

    Shi, W., Cao, J., Zhang, Q., Li, Y., & Xu, L. (2016). Edge computing: Vision and challenges. IEEE internet of things journal, 3(5), 637-646

    2016

  5. [5]

    Deelman, E., et al. (2015). Pegasus: Workflow Management System. 12

    2015

  6. [6]

    Marz, N., & Warren, J. (2014). Apache Storm: Distributed Stream Processing

    2014

  7. [7]

    ActiveEon & INRIA. (2020). ProActive Parallel Suite User Manual

    2020

  8. [8]

    Doe, J., & Smith, A. (2019). A visual programming framework for distributed IoT-centric complex event processing. Computers & Electrical Engineering

    2019

  9. [9]

    Pan, H., et al. (2024). Octopus: Hybrid Event-Driven Architecture for Distributed Scientific Computing. arXiv:2407.11432

    work page arXiv 2024

  10. [10]

    Myers, B. A. (1990). Taxonomies of visual programming and program visualization. Journal of Visual Languages & Computing, 1(1), 97-123

    1990

  11. [11]

    Zhu, W., Goudarzi, M., & Buyya, R. (2023). FLight: A Lightweight Federated Learning Framework in Edge and Fog Computing. arXiv:2308.02834

    work page arXiv 2023

  12. [12]

    O., Koçyiğit, A., & Eren, P

    Gökalp, M. O., Koçyiğit, A., & Eren, P. E. (2019). A visual programming framework for distributed Internet of Things centric complex event processing. Computers & Electrical Engineering, 74, 581-604

    2019

  13. [13]

    Ray, P. P. (2017). A survey on visual programming languages in internet of things. Scientific Programming, 2017(1), 1231430

    2017

  14. [14]

    Katevas, K., Perino, D., & Kourtellis, N. (2022). FLaaS: Cross-App On-device Federated Learning in Mobile Environments. arXiv preprint arXiv:2206.10963

    work page arXiv 2022

  15. [15]

    Cabane, H., & Farias, K. (2024). On the impact of event-driven architecture on performance: An exploratory study. Future Generation Computer Systems, 153, 52-69

    2024

  16. [16]

    T., & Bagchi, S

    Li, X., Abdallah, M., Suryavansh, S., Chiang, M., Kim, K. T., & Bagchi, S. (2022, September). DAG-based task orchestration for edge computing. In 2022 41st International Symposium on Reliable Distributed Systems (SRDS) (pp. 23-34). IEEE

    2022

  17. [17]

    L., Olivares, T., & Fernández-Caballero, A

    Roda-Sanchez, L., Garrido-Hidalgo, C., Royo, F., Maté-Gómez, J. L., Olivares, T., & Fernández-Caballero, A. (2023). Cloud–edge microservices architecture and service orchestration: An integral solution for a real-world deployment experience. Internet of Things, 22, 100777

    2023

  18. [18]

    Chini, F., De Martini, L., Margara, A., & Cugola, G. (2025). FlowUnits: Extending Dataflow for the Edge-to-Cloud Computing Continuum. arXiv preprint arXiv:2504.11400

    work page arXiv 2025

  19. [19]

    Y., Chen, G

    Chiang, Y., Zhang, Y., Luo, H., Chen, T. Y., Chen, G. H., Chen, H. T., ... & Chou, C. T. (2023). Management and orchestration of edge computing for IoT: A comprehensive survey. IEEE Internet of Things Journal, 10(16), 14307-14331

    2023

  20. [20]

    Rosendo, D., Costan, A., Valduriez, P., & Antoniu, G. (2022). Distributed intelligence on the edge-to-cloud continuum: A systematic literature review. Journal of Parallel and Distributed Computing, 166, 71-94

    2022

  21. [21]

    Gilles, K. A. H. N. (1974). The semantics of a simple language for parallel programming. Information processing, 74(471-475), 15-28

    1974

  22. [22]

    A., & Parks, T

    Lee, E. A., & Parks, T. M. (2002). Dataflow process networks. Proceedings of the IEEE, 83(5), 773-801

    2002

  23. [23]

    McMahan, B., Moore, E., Ramage, D., Hampson, S., & y Arcas, B. A. (2017, April). Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics (pp. 1273-1282). PMLR

    2017

  24. [24]

    K., Talwalkar, A., & Smith, V

    Li, T., Sahu, A. K., Talwalkar, A., & Smith, V. (2020). Federated learning: Challenges, methods, and future directions. IEEE signal processing magazine, 37(3), 50-60

    2020

  25. [25]

    B., Avent, B., Bellet, A., Bennis, M., Bhagoji, A

    Kairouz, P., McMahan, H. B., Avent, B., Bellet, A., Bennis, M., Bhagoji, A. N., ... & Zhao, S. (2021). Advances and open problems in federated learning. Foundations and trends® in machine learning, 14(1–2), 1-210

    2021