The advent of distributed ledger technology across various sectors highlighted its potential to revolutionize conventional processes and systems. In particular, smart contracts emerged as disruptive innovation, automating legal contract clauses between parties. However, smart contract development is not an easy task and raises nontrivial challenges to non-programmers since they need to have specialized programming skills and deep understanding of blockchain technology. These challenges reduce user engagement and increase the possibility of introducing bugs and vulnerabilities that can lead to huge financial loss. To address these complexities, visual programming has emerged as the main solution among researchers since it is a well-proven methodology to improve and lower the learning curve of a new programming language and create a working piece of code in a userfriendly way. This paper aims to assess the visual formalism and representation that have been used in academia to represent smart contracts in an easy-to-understand manner. The findings show a clear evolution in visualization approaches, with Business Process Model Notation (BPMN) emerging as the dominant methodology (35%) in recent years. Behavioral visualizations (52.5%) have increasingly replaced structural representations (37.5%) as the ifeld matures, whereas evolution-focused approaches remain underexplored (10%). Despite balanced accessibility requirements across user expertise levels, only 20% of studies incorporate formal UX testing, suggesting significant opportunities to improve user-centered design in the visualization of smart contracts.
to huge financial losses. This has promoted extensive research eforts to develop vulnerability detection
methods before deployment [
The paper is organized as follows. In Section 2 a useful key aspect is provided to introduce the context and rationale behind this work. Section 3 provides the research methodology used to carry out the analysis. The main categories of smart contract visualization identified from the analysis of the selected articles are presented in Section 4 while the mapping and analysis of the selected papers are presented in Section 5. Finally, conclusions are reported in Section 6.
Understanding complex software systems requires efective methods to clearly represent how they operate. Visualization approaches in software engineering have been widely adopted to support this need. In parallel, the emergence of smart contracts has introduced new programming paradigms that demand both security and formal correctness. These contracts are typically developed using specialized programming languages such as Solidity, the most widely used language for Ethereum, as well as Vyper and Rust (commonly used on platforms like Solana and NEAR). Although these languages emphasize determinism and transparency, their syntactic and semantic complexity can pose significant challenges for novice developers. The integration of visual programming and visualization techniques into smart contract development ofers promising potential to improve accessibility, comprehension, and reliability. The following section provides an overview of both software visualization techniques and the programming languages used to develop smart contracts, in order to clarify the rationale behind the design choices made in proposing a visual programming solution in literature for smart contract development.
Three main categories have been identified in general software visualization: structure, evolution, and
behavior [
Smart contracts are executable rules that can be triggered by the users with transactions. Smart contract programming languages enable developers to create self-executing agreements on blockchain platforms. These languages vary significantly in their programming paradigms, type systems, and state management approaches, reflecting the diverse architectural choices of their respective blockchain platforms. Rust serves as Solana’s primary smart contract language, implementing a stateless accountbased model where procedures operate on separate data accounts. The Anchor framework helps abstract away some of Rust’s complexity in the blockchain context. Aiken, a functional language for Cardano, works with the extended UTXO model, requiring developers to specify transaction validation conditions rather than procedural state changes. Move, embedded in platforms like Aptos, features linear types to ensure that tokens cannot be replicated or lost. PyTEAL provides Python bindings for Algorand’s TEAL bytecode, while SmartPy ofers meta-programming capabilities for Tezos. Each language makes diferent trade-ofs in terms of expressiveness, safety, and abstraction level. Last but not least, Solidity, developed in 2014, remains the dominant high-level language for Ethereum Virtual Machine (EVM) compatible blockchains including Ethereum, Avalanche C-Chain, and Hedera. Using a JavaScript-like syntax with object-oriented features, Solidity follows an account-based stateful model where contracts act like classes with methods and storage. Despite its accessibility, Solidity has design quirks that can lead to security vulnerabilities in decentralized applications. Most of the works present in the literature target the visual representation of smart contract that are then translated in Solidity since it is the most widely spread smart contract programming language [19].
Despite some relevant work in the literature, there remains a significant need to comprehensively map and analyze visual formalisms for smart contracts. Vieira and Vilain [20] demonstrated that state diagrams can efectively visualize smart contracts, improving comprehension and development accuracy. Their research identified visualization techniques including finite-state machines, UML state machine diagrams, Business Process Model Notation (BPMN), and Petri Nets, with experiments showing that state diagrams significantly reduced comprehension time compared to natural language descriptions alone. Their approach bridged the semantic gap between legal contracts and technical implementations while making smart contracts more accessible to non-technical stakeholders. Furthermore, Curty et al. [21] highlight that the creation of blockchain-based software applications requires considerable technical knowledge, particularly in software design and programming. This is regarded a major barrier to adopting this technology in business and making it accessible to a wider audience. As a solution, low-code and no-code approaches have been proposed that require only little or no programming knowledge to create full-fledged software applications. Their review of academic approaches from the discipline of model-driven engineering, as well as industrial low-code and no-code development platforms for blockchains, includes a content-based, computational analysis of relevant academic papers and the derivation of major topics.
Our work aims to map and analyze the visual formalisms proposed in literature to represent smart contracts in terms of source code, interaction, or state evolution. As demonstrated in Section 2.1, visual approaches can significantly improve the comprehension of source code and reduce the cognitive workload of users. By systematically investigating the various visualization techniques employed across diferent smart contract platforms and programming languages, this work aims to identify efective representation patterns, uncover gaps in existing approaches, and propose standardized visualization practices that could enhance both educational results and professional development workflows in the smart contract ecosystem.
To achieve the objectives of this study, an initial search was performed using the SCOPUS search engine to establish familiarity with the existing literature on the subject matter. SCOPUS includes scientific databases including ACM Digital Library, IEEE Xplore, Elsevier, Wiley, and Springer. The search used multiple strings: (“smart contrac”) AND ((“visualization” OR “representation”) OR (“visual” AND “abstraction”) OR (“visual” AND “representation”) OR (“visual” AND “programming”)).
After the initial collection, 421 papers were screened first by title and then by abstract to determine relevance. For a paper to be included in the final review, it needed to meet the following criteria: • be written in English; • be available in full text online; • ofer a clear visual representation of smart contracts in at least one of the following aspects: structure of the source code, business interactions between parties, or evolution of the transition states of the smart contract.
A significant number of papers were excluded because they focused on graph neural networks or merely presented their findings in a visual way rather than ofering visual representations of the smart contracts themselves. Articles that did not meet these criteria were excluded from further analysis. Following the collection of initial resources, the search was expanded to include relevant articles resulting from strings “smart contract” AND (“no-code” OR “low-code” OR “bpmn” OR “mda” or “uml”) which led to the selection of 119 articles. A secondary search was conducted through the citations and references identified during the primary search process.
The investigation yielded 40 scholarly articles relevant to the research focus after the screening phase and the elimination of duplicates. Informed conclusions regarding the current state of the field were derived through in-depth examination of these papers, and potential avenues for future enhancement within this domain were identified.
The following section provides a summary of various approaches to visual representation of smart contracts proposed by academia. To facilitate a clearer understanding, the approaches are categorized in Block-based, Model-Driven, and Custom visualization approaches. The proposed visual solutions are presented in Table 1 reporting visual methodology, visual category (as explained in Section 2.1), public availability of the tool, presented use case, target user, and whether the usability of the proposed tool has been tested.
Several researchers have adapted UML for smart contract visualization. Marchesi et al. [22] extended traditional UML diagrams with specialized formalisms for Solidity constructs and enhanced sequence diagrams with blockchain-specific stereotypes. Garamvolgyi et al. [ 23] employed UML statecharts to model cyber-physical systems, capturing complex interactions between physical devices and their blockchain representations. Pierro [24] developed Smart-Graph to generate augmented UML class diagrams that include Solidity-specific constructs absent from traditional UML standards. Heckel et al. [25] created a visualization framework using UML-inspired class diagrams enriched with domainspecific stereotypes for DAML templates. Jurgelaitis et al. [ 26] proposed MDAsmartCD, a comprehensive UML-based framework that spans the entire model-driven architecture lifecycle with blockchain-specific extensions. Ghafari Saadat [ 27] presented a unique approach using symbolic attributed graph grammars to visualize smart contracts through typed graphs with color-coded transformation rules.
A significant research trend employs block-based visual programming to make smart contract development accessible. Weingärtner et al. [28] introduced a modular Blockly framework that organizes blocks into types, delivery options, and contractual options. Guida and Daniel [29] developed SolidityEditor with more than 70 custom blocks for Solidity constructs. Mao et al. [30] combined Blockly with neural code generation to produce function templates encapsulated in visual blocks. Merlec et al. [31] presented SmartBuilder, organizing blocks into functional domains while providing natural language summaries. Trestioreanu et al. [32] created Blockly2Hooks for XRP Ledger development with an end-to-end pipeline from visual programming to deployment. Gomez et al. [33] introduced SmaCly with predefined ERC-standard templates and semantic compatibility enforcement. Tsai et al. [34] developed an educational framework extending Blockly for blockchain education among K-12 students.
These visualization methodologies share several key objectives regardless of their underlying formalism. All approaches aim to abstract programming complexity and enforce structural correctness. UML-based approaches excel at modeling system architecture and behavioral semantics, while blockbased systems focus on executable code generation and practical development.
Most frameworks provide immediate feedback loops between visual representation and generated code. Several techniques incorporate domain-specific extensions to capture blockchain-specific concepts missing in standard modeling notation. There is also a consistent emphasis on lowering technical barriers for non-experts while preserving the semantic richness required for blockchain applications. rm c e is B B A B In aB Itn In aB
t s t ity en l i m ib e s ir s e u c
i c q s c e e c an s r n
o su i
t n c
a y s a n t a i d e m r e t n I o ] 0 4 1 2 0 2 r r g g o o r r P p t d eS se r a e b s e n i c c a v f o g n i k c k o a rT le o p
H t m e a fs s h D p E a R r y - g l e se o o o o o o se se o se r u i t c u tr eh tr
u i e r e n e r r o r o r t u i
e e o r r
u u o i v v t a
t u c c l u
a u u vo tr eh eh tr t
r v t a c u t c r o i v a h e e B B r o d e c n a v d s s e c o r p m a x e s y ] ] 7 8 4 4 [ [
P n y r e
N N Y Y N Y N Y Y Y N Y N Y N N N N N N Y Y N Y L N M ST rao O T E h lo
M M lo lo
ly ly ck L L ck k N c
n L io L L L
N t M c
M M M M P y l k N
w c M s lo P n lo ] ] ] ] ] ] ] ] ] 1 1 2 3 5 4 5 6 2 3 4
4 4 2 4 4 4 3 [ [ [ [ [ [ [ [ [ r o i v a h e e e n e e r r o r r u t
u u t c u r r t t u i t c l u
t u c
u vo tr t r t c u e e r e e r r r o r r o u t c u i t c u
u v t
c u r r t t S S B S S B a a
u u h eh tr tr e u i t v c I U y l s e d o n f o h p a r g e s a c e s
U e l ab e l n i i 0 0 0 1 1 1 2 2 2 2 2 2 0 0 0 0 0 0 0 2 2 2 2 2 2 2 s e t X r e t In A B B In In d e m e e t t ia i
a u s A o o u 2 7 / o o 2 4 N N 9 1 1 N N N o o o o a v d a h e B M P B ] 6 h h e e B B x N x M O P D B A ] ] 7 8 5 5 l ab e l n i i a l v n h c a o r p p n i e c n e r e f e ] 9 4 2 0 2 a t a m o t u A d e m i T f o k r o h p a r G w o l F l ] ] 0 6 5 2
[ 3 2 0 2 3 2 e c a o r i u t s c n n fic i t o n le i
E l y a d s l n e i l g ir n b l N g
e t u in in S t d a d e n h n
C a f i
r o t n r io t a t n id l a t e
u sc m p s i e f n w n t o p eb itc e c u cn sn
a s o
i u n s o s i e t a m fic r d i t a l gu ss
li c e e le k u s n g o b iz o e g n i d o c s ’ t n o i t n c u i r c t s n o d c g in e d a t c o d r t a t e l t e o n e
o p c u t a r e t m ad s h ta e m e t s y s t n n e
m m e s s g e a a s n
s a m a
n g a t n l fic o a k it m e t s y s t n e i m l e c g l se e a
d a c
t e s i
n in h i g t t l o o r
R fu g g d ly g w p i
g n an it o o
c o p y u u a is l
t i T e a r D s e o e h u o ik fic U F V V C S B M V T R C P B G T r s o a f zz ruh aan tean a a c i m n o FT rea a e i n e n n r O P N L B C P P M R M S Icn lB B C E H M O D a u l R l i
e t n pp id o ek fe am te l u o i o x o u
n y e d
n o e t c o p l
M P
A e m re e d e e r g s a i m ry in n s
o a a t
h c c t a ly l i m an ta
c n a r e u g i n ed in o t
h t h c k
C o o o e B l s e A O Y e e o se o o se o o s s Y Y N Y N N Y N N
e e r r r r r r o r o i v a h e B n r o i t u l o r r i u v t a c
u o h r u v e t t E B S S B B a a h h r e e u i t c o io v v N
N
N M
M V
B C B B B B L w t
M e P B U N
N tro ly ly
k M n P o l c c M M o lo P P i i a l v n se A O Y za ry r i l a o io g v su te a i a eh V C B
A l a N u s M i
P V B h c a o r p N M P B ] 0
BPMN has emerged as the dominant visualization framework for model-driven smart contract development, with researchers adapting its notation for blockchain contexts in various ways. Several approaches focus on choreography and multi-party collaboration. López-Pintado et al. [36] introduced Caterpillar, which uses single-pool BPMN models in which stakeholders appear as lanes, replacing message-based coordination with sequence flows to represent blockchain as a unified coordination mechanism. Similarly, Shen et al. [56] used BPMN choreography diagrams to visualize collaborative processes through message exchanges, with participant bands distinguishing initiators from recipients. Samanipour et al. [59] selected choreography diagrams for their MDAPW3 framework specifically to represent peer-to-peer interactions in decentralized applications. Security and flexibility concerns have been addressed through specialized BPMN extensions. Kopke et al. [50] improved BPMN with blockchain-specific annotations including train symbols for enforceability and chain symbols for onchain execution. Corradini et al. [48] developed FlexChain, using BPMN choreography diagrams to address the tension between blockchain immutability and business process flexibility. Several researchers have explored transformation methodologies from BPMN to smart contract code. El Abidi et al. [55, 57] developed systematic approaches to translate BPMN elements into Solidity constructs through ranking processes and meta-model integration. Jin et al. [54] employed a two-step transformation process that converts BPMN models into Prolog statements for validation before generating Go language smart contracts. Gao et al. [60] introduced BPMN-LLM, using large language models to transform BPMN diagrams into smart contracts, where swimlanes denote parties and gateway types capture conditional logic. Some approaches combine BPMN with other visualization techniques. Shen et al. [49] integrated customized BPMN modeling with Google Blockly’s visual programming environment, distinguishing between participant actions and smart contract operations through specialized swimlanes. Ye et al. [52] developed a three-tier visual framework mapping BPMN tasks to smart contract functions with color-coded indicators reflecting execution states. Alternative state-based approaches include Meng et al.’s [40] EFSMSolid framework, which employs Extended Finite State Machines to represent contractual phases and transitions. Ye and Konig [41] selected YAWL (Yet Another Workflow Language) for its formal semantics while supporting practical control-flow patterns that construction professionals could understand. Industry-specific implementations such as Rosa-Bilbao et al. [ 45]propose EDALoCo which extends Node-RED to create a modular low-code framework with blockchain-oriented nodes classified by functionality, while Bodorik et al. [ 47] transformed BPMN through an intermediate EventHierarchical State Machine representation to identify patterns for sidechain deployment. Collectively, these BPMN-based approaches demonstrate the notation’s versatility in representing smart contract elements – participants, roles, actions, obligations, and constraints – while providing visual abstractions accessible to both technical and non-technical stakeholders.
Several researchers have developed specialized visualization techniques specifically design for smart contracts. Bragagnolo et al. [35] created SmartInspect, which uses a mirror-based reflection system to visualize the contract state through hierarchical tree structures, making complex data interpretable without redeployment. Rather than using standard frameworks, they developed a custom decompilation technique for dynamic representation of contract data.
Node-based interfaces have emerged as a popular approach. Tan et al. [37] introduced LATTE, which represents contract elements as interconnected nodes in action graphs with semantic parsing capabilities. Similarly, Hdhili et al. [43] employed flow-based programming to depict smart contracts as executable graphs of modular boxes showing input-output relationships, demonstrating improved comprehension among non-experts.
Several frameworks target domain experts through specialized visual languages. Bistarelli et al. [44] developed a DSL for supply chain contracts where assets, operations, containers, and roles are represented through standardized graphical components. Curty and Fill [58] proposed SmartCML, using decorated circles for actions and explicit relations to distinguish between read and write operations on the contract state.
For formal modeling, researchers have explored various notations. Prunell and Schwitter [42] created a Smart Document Editor using color-coded bars and distinctive icons aligned with Answer Set Programming. Eshgie et al. [46] used DCR graphs with styled arrows representing diferent constraints, while Qin et al. [51] used state transition diagrams to capture contract clauses as networks of states with annotated edges.
Some approaches integrate multiple visualization techniques. Skotnica et al. [38] proposed a metamodel decomposing contract logic into interrelated diagrams, including a Contract Action Model using Google Blockly for executable logic. In subsequent work [39], they introduced DasContract, combining data models, process models, and form models to generate Solidity code. Wen et al. [53] developed a hierarchical visualization system that transforms bytecode into semantic action sequences, using color-coded charts, parallel sequences, and node-link diagrams with specialized iconography.
These custom approaches collectively demonstrate diverse strategies for visualizing smart contracts, emphasizing relationships between parties, representing execution paths, modeling state changes, and abstracting complex programming constructs for improved usability and understanding.
The analysis of the selected work on smart contract visualization from 2018 to 2025 reveals distinct patterns in the adoption of visualization methodology.
As shown in Figure 1a BPMN represents 35% (14 papers) of the studies, making it the most popular methodology. Blockly and UML follow closely with 17.5% (7 papers) and 20% (8 papers) respectively. The remaining 27.5% (11 papers) utilize various visualization approaches, including DCR graphs, Answer Set Programming, Network of Timed Automata, Flow-based programming, EFSM Model, DSL, Node-RED, JSON/HTML/REST interfaces, and ADOxx.
The temporal distribution of these methodologies, depicted in Figure 1b, reveals a significant evolution in the field. From 2018 to 2020, approaches were dominated by more general-purpose visualization languages such as UML and Blockly, which were favored for their accessibility and familiarity to software developers. This period established the foundational visualization approaches in the emerging ifeld of smart contract visualization. The years 2021-2022 marked a transition period characterized by methodological diversity. Researchers began exploring specialized approaches such as EFSM, DCR graphs, and custom visualizations tailored to the unique requirements of blockchain environments. This diversification signaled a maturing understanding of the specific challenges in visualizing smart contracts. Most notably, from 2023 to 2025, a pronounced shift toward BPMN is observed as the dominant methodology. Of the 14 BPMN-based studies, 11 were published during this recent period. This convergence suggests an emerging consensus around BPMN’s suitability for modeling the procedural nature and complex interactions of smart contracts. The standardization around BPMN may also reflect a move toward industry adoption, as BPMN is widely used in business contexts.
The conducted analysis categorizes the visualizations into three distinct types. Taking as reference the Figure 1c, there is the following distribution: • Structure (15 studies, 37.5%): focusing on compositional aspect of smart contract source code; • Behavior (21 studies, 52.5%): emphasizing the dynamic execution and interaction patterns of smart contracts; • Evolution (4 studies, 10%): addressing the temporal dimension and smart contract modifications. (a) Distribution of Visual Approaches (b) Papers by Year and Visual Approach (c) Distribution of Visualization Categories (d) Papers by Year and Visualization Category (e) Distribution of Accessibility Requirements (f) Cumulative Papers by Year
The distribution in Figure 1d shows a progressive shift from structural representations toward behavioral ones. Early research (2018-2021) predominantly focused on structural visualization (11 out of 15 structure-focused papers are published in this period), which addresses the fundamental question of how smart contracts are composed. As the field matured, particularly from 2022 onward, behavioral visualizations gained prominence (16 out of 21 behavior-focused papers published in this period), reflecting an increased interest in how contracts execute and interact with users and other contracts. This transition aligns with the natural progression of the field: researchers first needed to establish how to represent what smart contracts are before moving on to visualizing how they behave. The limited number of evolution-focused visualizations (10%) suggests an opportunity for future research, particularly as contract upgradability and adaptation become more critical in production environments.
The distribution of accessibility requirements in the studies depicted in Figure 1e reveals a balanced approach to user expertise: • Basic: 16 studies (40%); • Intermediate: 13 studies (32.5%); • Advanced: 11 studies (27.5%).
This relatively uniform distribution suggests that researchers are considering various user profiles, from novices to experienced developers. In particular, block-based visualizations predominantly target basic accessibility levels, making them suitable for educational purposes and newcomers to smart contract development. In contrast, BPMN-based approaches tend toward intermediate and advanced requirements, reflecting their use in more complex scenarios. The analysis revealed a concerning gap in user experience validation. As Table 1 highlights, only 8 out of 40 studies (20%) incorporated formal UX testing, most of which involve relatively small sample sizes (6-17 participants). Notable exceptions include studies by Hdhili et al. [43] and Kopke et al. [50], with 58 and 42 participants, respectively. This limited focus on user experience suggests that smart contract visualization remains primarily in the technical development phase, with insuficient attention to end-user needs and usability. However, we observe a positive trend in recent years (2023-2025), where 6 of the 8 studies with UX testing were published, indicating a growing recognition of user-centered design principles.
The use cases that span the 40 studies demonstrate remarkable diversity, as reported in Table 1, including: • Financial Services: voting systems, auctions, lending platforms, insurance claims; • Supply Chain Management: product tracking, trade verification, manufacturing processes; • Real Estate: property transactions, mortgage processing, leasing agreements; • Healthcare: patient records, hospital procedures, tele-consultation; • Education: certificate issuance, exam management; • General Business Processes: payment systems, purchasing workflows.
This broad application spectrum indicates that smart contract visualization is being explored across multiple domains rather than being confined to specific industries. The diversity of use cases underscores the versatile applicability of smart contracts and the universal need for efective visualization regardless of the application domain.
In general, looking the Figure 1f showing cumulative papers by year, a steady growth in research publications proposing visual methods for smart contract source code representation can be observed. Starting with just 4 papers in 2018, the field has shown consistent annual growth, with particularly strong publication increases in 2021 (+6 papers), 2023 (+7 papers), and 2024 (+9 papers). By 2025, the cumulative total reaches 40 publications, representing a ten-fold increase from the initial baseline. This growth pattern suggests increasing research interest in visual representations of smart contracts, likely driven by the expanding adoption of blockchain technologies and the need for more accessible ways to understand and verify complex smart contract code. The acceleration in publications from 2021 onward may reflect the maturation of the field as researchers build upon earlier visualization approaches and address more sophisticated representation challenges. The consistent year-over-year increases, rather than sporadic jumps, indicate sustained interest rather than temporary research trends, suggesting that this is becoming an established research domain within the broader fields of software visualization and blockchain technology.
The analysis carried out aims to map the visualization formalisms and techniques presented so far by the academia to represent smart contracts, self-executing pieces of code that run on the blockchain. After a search phase on the Scopus database, 40 papers have been taken into account to perform the analysis, revealing a clear evolutionary trajectory in smart contract visualization from 2018 to 2025. The field has progressed from structure-focused to behavior-focused visualizations, with an emerging convergence around BPMN as a preferred methodology. Despite this maturation, significant opportunities remain for improving user experience evaluation and developing visualizations that address contract evolution. These findings suggest that while the technical foundations of smart contract visualization are becoming well-established, additional research is needed to bridge the gap between technical capability and practical usability. The balanced distribution across accessibility levels indicates awareness of diverse user needs, but the limited UX testing highlights the need for greater emphasis on user-centered design approaches as these visualization methodologies transition from academic exploration to practical industry adoption.
The work discussed in this paper has been supported by the B4A - Blockchain for All project (https://www.blockchain4all.it/), ref. no. 20225MN5K3. This project has been funded with support from the Ministry of Education, University and Research. This document reflects the views only of the authors, and the Ministry of Education, University and Research cannot be held responsible for any use which may be made of the information contained therein.
During the preparation of this work, the author(s) used Claude-3.7-Sonnet and Deepl to perform grammar and spelling checks. After using these tools, the authors reviewed and edited the content as needed and assumed full responsibility for the content of the publication. Association for Computing Machinery, New York, NY, USA, 2023. URL: https://doi.org/10.1145/ 3544548.3581390. doi:10.1145/3544548.3581390. [6] K. E. Isaacs, T. Gamblin, Preserving command line workflow for a package management system using ascii dag visualization, IEEE Transactions on Visualization and Computer Graphics 25 (2019) 2804–2820. doi:10.1109/TVCG.2018.2859974. [7] S. Devkota, K. E. Isaacs, CFGExplorer: Designing a Visual Control Flow Analytics System around Basic Program Analysis Operations, Computer Graphics Forum 37 (2018) 453– 464. URL: https://onlinelibrary.wiley.com/doi/abs/10.1111/cgf.13433. doi:10.1111/cgf.13433, _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1111/cgf.13433. [8] Y. Yoon, B. A. Myers, S. Koo, Visualization of fine-grained code change history, in: 2013 IEEE Symposium on Visual Languages and Human Centric Computing, 2013, pp. 119–126. doi:10. 1109/VLHCC.2013.6645254. [9] F. Zhou, Y. Fan, S. Lv, L. Jiang, Z. Chen, J. Yuan, F. Han, H. Jiang, G. Bai, Y. Zhao, Fctree: Visualization of function calls in execution, Inf. Softw. Technol. 175 (2024). URL: https://doi.org/10.1016/j.infsof. 2024.107545. doi:10.1016/j.infsof.2024.107545. [10] K. E. Isaacs, P.-T. Bremer, I. Jusufi, T. Gamblin, A. Bhatele, M. Schulz, B. Hamann, Combing the communication hairball: Visualizing parallel execution traces using logical time, IEEE Transactions on Visualization and Computer Graphics 20 (2014) 2349–2358. doi:10.1109/TVCG.2014.2346456. [11] K. Xu, Y. Wang, L. Yang, Y. Wang, B. Qiao, S. Qin, Y. Xu, H. Zhang, H. Qu, Clouddet: Interactive visual analysis of anomalous performances in cloud computing systems, IEEE Transactions on Visualization and Computer Graphics 26 (2020) 1107–1117. doi:10.1109/TVCG.2019.2934613. [12] Y. Sun, Y. Zhang, A. Mosallaei, M. D. Shah, C. Dunne, D. Kaeli, Daisen: A Framework for Visualizing Detailed GPU Execution, Computer Graphics Forum 40 (2021) 239–250. URL: https://onlinelibrary.wiley.com/doi/abs/10.1111/cgf.14303. doi:10.1111/cgf.14303, _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1111/cgf.14303. [13] Q. Yu, K. Yu, B. Li, Efects of Block-Based Visual Programming on K-12 Students’ Learning Outcomes, Journal of Educational Computing Research 63 (2025) 64–98. URL: https://doi.org/10. 1177/07356331241293163. doi:10.1177/07356331241293163, publisher: SAGE Publications Inc. [14] D. Pereira, F. Barbosa, C. Morgado, NextBlocks: An Interactive Block Programming Platform, in: Proceedings of the 2024 on Innovation and Technology in Computer Science Education V. 1, ITiCSE 2024, Association for Computing Machinery, New York, NY, USA, 2024, pp. 590–596. URL: https://dl.acm.org/doi/10.1145/3649217.3653609. doi:10.1145/3649217.3653609. [15] M. Seraj, M. Verano Merino, E. Rahimi, L. Ochoa Venegas, Programming smart objects: How young learners’ programming skills, attitudes, and perception are influenced, in: Proceedings of the 2024 ACM SIGPLAN International Symposium on SPLASH-E, SPLASH-E ’24, Association for Computing Machinery, New York, NY, USA, 2024, p. 45–55. URL: https://doi.org/10.1145/3689493.3689982. doi:10.1145/3689493.3689982. [16] S. Thorgeirsson, T. B. Weidmann, K.-H. Weidmann, Z. Su, Comparing cognitive load among undergraduate students programming in python and the visual language algot, in: Proceedings of the 55th ACM Technical Symposium on Computer Science Education V. 1, SIGCSE 2024, Association for Computing Machinery, New York, NY, USA, 2024, p. 1328–1334. URL: https: //doi.org/10.1145/3626252.3630808. doi:10.1145/3626252.3630808. [17] S. Thorgeirsson, C. Zhang, T. B. Weidmann, K.-H. Weidmann, Z. Su, An Electroencephalography Study on Cognitive Load in Visual and Textual Programming, in: Proceedings of the 2024 ACM Conference on International Computing Education Research - Volume 1, ACM, Melbourne VIC Australia, 2024, pp. 280–292. URL: https://dl.acm.org/doi/10.1145/3632620.3671124. doi:10.1145/ 3632620.3671124. [18] S. Thorgeirsson, O. Graf, Explaining Algorithms with the Visual Programming Language Algot, in: Proceedings of the 2024 on Innovation and Technology in Computer Science Education V. 2, ITiCSE 2024, Association for Computing Machinery, New York, NY, USA, 2024, pp. 783–784. URL: https://dl.acm.org/doi/10.1145/3649405.3659520. doi:10.1145/3649405.3659520. [19] L. Luu, D.-H. Chu, H. Olickel, P. Saxena, A. Hobor, Making smart contracts smarter, in: Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, CCS ’16, Association for Computing Machinery, New York, NY, USA, 2016, p. 254–269. URL: https://doi.org/ 10.1145/2976749.2978309. doi:10.1145/2976749.2978309. [20] M. L. L. Vieira, P. Vilain, Representation of smart contracts as state diagrams, in: 2021 IEEE/ACS 18th International Conference on Computer Systems and Applications (AICCSA), 2021, pp. 1–8. doi:10.1109/AICCSA53542.2021.9686862. [21] S. Curty, F. Härer, H. Fill, Design of blockchain-based applications using model-driven engineering and low-code/no-code platforms: a structured literature review, Softw. Syst. Model. 22 (2023) 1857– 1895. URL: https://doi.org/10.1007/s10270-023-01109-1. doi:10.1007/S10270-023-01109-1. [22] M. Marchesi, L. Marchesi, R. Tonelli, An agile software engineering method to design blockchain applications, in: Proceedings of the 14th Central and Eastern European Software Engineering Conference Russia, CEE-SECR ’18, Association for Computing Machinery, New York, NY, USA, 2018. URL: https://doi.org/10.1145/3290621.3290627. doi:10.1145/3290621.3290627. [23] P. Garamvölgyi, I. Kocsis, B. Gehl, A. Klenik, Towards model-driven engineering of smart contracts for cyber-physical systems, in: 2018 48th Annual IEEE/IFIP International Conference on Dependable Systems and Networks Workshops (DSN-W), 2018, pp. 134–139. doi:10.1109/DSN-W. 2018.00052. [24] G. A. Pierro, Smart-graph: Graphical representations for smart contract on the ethereum blockchain, in: 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), 2021, pp. 708–714. doi:10.1109/SANER50967.2021.00090. [25] R. Heckel, Z. Erum, N. Rahmi, A. Pul, Visual smart contracts for daml, in: N. Behr, D. Strüber (Eds.), Graph Transformation, Springer International Publishing, Cham, 2022, pp. 137–154. [26] M. Jurgelaitis, L. Čeponienė, K. Butkus, R. Butkienė, V. Drungilas, Mda-based approach for blockchain smart contract development, Applied Sciences 13 (2023). URL: https://www.mdpi.com/ 2076-3417/13/1/487. doi:10.3390/app13010487. [27] M. Ghafari Saadat, R. Heckel, F. Orejas, Unfolding symbolic attributed graph grammars, in: F. Gadducci, T. Kehrer (Eds.), Graph Transformation, Springer International Publishing, Cham, 2020, pp. 75–90. [28] T. Weingaertner, R. Rao, J. Ettlin, P. Suter, P. Dublanc, Smart Contracts Using Blockly: Representing a Purchase Agreement Using a Graphical Programming Language, in: 2018 Crypto Valley Conference on Blockchain Technology (CVCBT), 2018, pp. 55–64. URL: https://ieeexplore.ieee.org/ document/8525393. doi:10.1109/CVCBT.2018.00012. [29] L. Guida, F. Daniel, Supporting reuse of smart contracts through service orientation and assisted development, in: 2019 IEEE International Conference on Decentralized Applications and Infrastructures (DAPPCON), 2019, pp. 59–68. doi:10.1109/DAPPCON.2019.00017. [30] D. Mao, F. Wang, Y. Wang, Z. Hao, Visual and User-Defined Smart Contract Designing System Based on Automatic Coding, IEEE Access 7 (2019) 73131–73143. URL: https://ieeexplore.ieee.org/ document/8730359. doi:10.1109/ACCESS.2019.2920776. [31] M. M. Merlec, Y. K. Lee, H. P. In, SmartBuilder: A Block-based Visual Programming Framework for Smart Contract Development, in: 2021 IEEE International Conference on Blockchain (Blockchain), 2021, pp. 90–94. URL: https://ieeexplore-ieee-org.ezproxy.biblio.polito.it/document/ 9680565. doi:10.1109/Blockchain53845.2021.00023. [32] L. A. Trestioreanu, W. M. Shbair, F. S. de Cristo, R. State, Blockly2Hooks: Smart Contracts for Everyone with the XRP Ledger and Google Blockly, in: 2023 IEEE International Conference on Decentralized Applications and Infrastructures (DAPPS), 2023, pp. 145– 150. URL: https://ieeexplore-ieee-org.ezproxy.biblio.polito.it/document/10237017. doi:10.1109/ DAPPS57946.2023.00027, iSSN: 2835-3498. [33] C. Gomez, J. Vara, F. Pérez-Blanco, D. Granada, A block-based web ide to ease the smart contract programming learning curve, IEEE Revista Iberoamericana de Tecnologias del Aprendizaje PP (2024) 1–1. doi:10.1109/RITA.2024.3487475. [34] Y.-C. Tsai, J.-Y. Huang, D.-R. Chiou, Empowering young learners to explore blockchain with userfriendly tools: a method using Google Blockly and NFTs, IET Blockchain 4 (2024) 324–334. URL: https://onlinelibrary.wiley.com/doi/abs/10.1049/blc2.12055. doi:10.1049/blc2.12055, _eprint: https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/blc2.12055. [35] S. Bragagnolo, H. Rocha, M. Denker, S. Ducasse, Smartinspect: solidity smart contract inspector, in: 2018 International Workshop on Blockchain Oriented Software Engineering (IWBOSE), 2018, pp. 9–18. doi:10.1109/IWBOSE.2018.8327566. [36] O. López-Pintado, L. García-Bañuelos, M. Dumas, I. Weber, A. Ponomarev, Caterpillar: A business process execution engine on the Ethereum blockchain, Software: Practice and Experience 49 (2019) 1162–1193. URL: https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.2702. doi:10.1002/ spe.2702, _eprint: https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.2702. [37] S. Tan, S. S Bhowmick, H. E. Chua, X. Xiao, LATTE: Visual Construction of Smart Contracts, in: Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data, SIGMOD ’20, Association for Computing Machinery, New York, NY, USA, 2020, pp. 2713–2716.
URL: https://dl.acm.org/doi/10.1145/3318464.3384687. doi:10.1145/3318464.3384687. [38] M. Skotnica, R. Pergl, Das contract - a visual domain specific language for modeling blockchain smart contracts, in: D. Aveiro, G. Guizzardi, J. Borbinha (Eds.), Advances in Enterprise Engineering XIII, Springer International Publishing, Cham, 2020, pp. 149–166. [39] M. Skotnica, J. Klicpera, R. Pergl, Towards model-driven smart contract systems-code generation and improving expressivity of smart contract modeling, Proc. EEWC 20 (2020). [40] J. Meng, Z. Li, R. Zhao, Y. Shang, An Automated Modeling Method and Visualization Implementation of Smart Contracts, in: H.-N. Dai, X. Liu, D. X. Luo, J. Xiao, X. Chen (Eds.), Blockchain and Trustworthy Systems, Springer, Singapore, 2021, pp. 399–406. doi:10.1007/978-981-16-7993-3_ 30. [41] X. Ye, M. König, From the graphical representation to the smart contract language: a use case in the construction industry, in: C. Feng, T. Linner, I. Brilakis, D. Castro, P.-H. Chen, Y. Cho, J. Du, S. Ergan, B. Garcia de Soto, J. Gaparík, F. Habbal, A. Hammad, K. Iturralde, T. Bock, S. Kwon, Z. Lafhaj, N. Li, C.-J. Liang, B. Mantha, M. S. Ng, D. Hall, M. Pan, W. Pan, F. Rahimian, B. Raphael, A. Sattineni, C. Schlette, I. Shabtai, X. Shen, P. Tang, J. Teizer, Y. Turkan, E. Valero, Z. Zhu (Eds.), Proceedings of the 38th International Symposium on Automation and Robotics in Construction (ISARC), International Association for Automation and Robotics in Construction (IAARC), Dubai, UAE, 2021, pp. 272–279. doi:10.22260/ISARC2021/0039. [42] K. Purnell, R. Schwitter, User-defined smart contracts using answer set programming, in: G. Long, X. Yu, S. Wang (Eds.), AI 2021: Advances in Artificial Intelligence, Springer International Publishing, Cham, 2022, pp. 291–303. [43] F. Hdhili, R. Gouiaa, M. Jansen, Implementation and evaluation of a visual programming language in the context of blockchain, in: J. Prieto, A. Partida, P. Leitão, A. Pinto (Eds.), Blockchain and Applications, Springer International Publishing, Cham, 2022, pp. 74–82. [44] S. Bistarelli, F. Faloci, P. Mori, Towards a graphical dsl for tracing supply chains on blockchain, in: R. Chaves, D. B. Heras, A. Ilic, D. Unat, R. M. Badia, A. Bracciali, P. Diehl, A. Dubey, O. Sangyoon, S. L. Scott, L. Ricci (Eds.), Euro-Par 2021: Parallel Processing Workshops, Springer International Publishing, Cham, 2022, pp. 219–229. [45] J. Rosa-Bilbao, J. Boubeta-Puig, A. Rutle, Edaloco: Enhancing the accessibility of blockchains through a low-code approach to the development of event-driven applications for smart contract management, Computer Standards Interfaces 84 (2022) 103676. doi:10.1016/j.csi.2022. 103676. [46] M. Eshghie, W. Ahrendt, C. Artho, T. T. Hildebrandt, G. Schneider, Capturing smart contract design with dcr graphs, in: C. Ferreira, T. A. C. Willemse (Eds.), Software Engineering and Formal Methods, Springer Nature Switzerland, Cham, 2023, pp. 106–125. [47] P. Bodorik, C. G. Liu, D. Jutla, TABS: Transforming automatically BPMN models into blockchain smart contracts, Blockchain: Research and Applications 4 (2023) 100115. URL: https://www. sciencedirect.com/science/article/pii/S2096720922000562. doi:10.1016/j.bcra.2022.100115. [48] F. Corradini, A. Marcelletti, A. Morichetta, A. Polini, B. Re, F. Tiezzi, A flexible approach to multi-party business process execution on blockchain, Future Generation Computer Systems 147