1. Introduction
Programming languages are essential for the development of systems and applications. They act as a bridge between humans and computers, facilitating control and the creation of software. Over time, a variety of programming languages have emerged, most of which use textual source code to create and represent computer programs [1,2]. During the evolution of programming languages, a category known as visual programming languages (VPLs) emerged. These languages create and represent computer programs graphically, using more than one dimension and incorporating a mix of text, colors, and shapes in their visual representations [3,4]. In Figure 1, we present some of the VPLs developed from 1966 to 2024, showcasing a clear trend of increasing innovation and development in this field. Early pioneering efforts are illustrated by the development of GPE (Graphical Program Editor) in 1966 and Pygmalion in 1975 [5,6], followed by subsequent languages such as Prograph, Simulink, and LabVIEW in the 1980s [7,8,9]. The 2000s saw the emergence of educational and accessible VPLs, like Scratch and Alice, which have become instrumental in teaching programming to younger audiences. For example, Scratch enables children to create stories, multimedia applications, and computer games using a user interface in their native language (Arabic, English, etc.) [10]. More recent advancements introduced in the literature include Envision, Node-RED, Blueprints, and FlowPilot, reflecting the continuous expansion and diversification of VPL applications [11,12,13,14,15].
Most visual programming languages are either used in education or specific fields. Only a few projects have been designed to be general-purpose and versatile. One of these projects is the Programming Without Coding Technology (PWCT), which supports code generation in multiple textual programming languages, such as C, Harbour, Python, and Supernova [16,17]. PWCT was used to create the compiler and virtual machine for the Ring programming language, as demonstrated in Figure 2, resulting in approximately a 23.5% increase in the level of abstraction when using the visual implementation.
This elevated level of abstraction leads to a more efficient development process by enabling developers to concentrate on the overall architecture and functionality of the program, instead of becoming entangled in the details of code syntax. The visual elements offer a more intuitive and user-friendly interface, making it simpler for developers to comprehend and alter the codebase. Moreover, this method enhances usability by lowering the chances of syntax errors [18,19,20].
PWCT has some drawbacks, such as requiring a large storage size for visual source files. Additionally, the Steps Tree Editor lacks features like rich comments and auto-run, and there are performance issues with code generation for large visual source files. Additionally, PWCT does not support the import of textual source code and is designed to operate exclusively on Microsoft Windows. Furthermore, the implementation of PWCT is based on Microsoft Visual FoxPro, which is no longer under active development. These issues need to be addressed when developing a new generation of PWCT [21,22,23].
The proposed PWCT2 design is influenced by advancements in other VPLs. For instance, the inclusion of rich colors and drag-and-drop functionality, as seen in Scratch, could enhance the user experience [24,25,26]. The visual steps editor could also be improved by adopting features from the Envision visual programming system, such as rich comments and interactive visualization. By integrating these proven features from other successful VPLs, PWCT2 can provide a more flexible and user-friendly environment [27].
Most VPLs are developed using textual programming languages; for example, the first generation of PWCT was developed using Visual FoxPro and Envision was developed using C++. Self-hosting PWCT2 is crucial, as it allows the development and modification of the PWCT2 environment using the same visual programming tools that it provides to users. This means that developers can update and enhance PWCT2 through visual programming rather than writing textual code, making the process more intuitive and accessible [28].
We assume that using the Ring programming language to develop PWCT2 could yield better results. The choice to transition from Visual FoxPro to the Ring programming language for the second generation of PWCT was driven by several key factors. Both Visual FoxPro and Ring are dynamic languages that support object-oriented programming (OOP), and each comes with an integrated development environment (IDE), a Graphical User Interface (GUI) framework, and a form designer, making them both suitable for many similar programming tasks. However, Ring distinguishes itself with the advantage of compatibility across multiple modern operating systems, which ensures that the new generation of PWCT can operate efficiently on various systems. Moreover, Ring was specifically designed for developing PWCT2. This decision not only leverages Ring’s strengths but also provides an excellent test of its features and capabilities, particularly since PWCT2 is an advanced project and, to our knowledge, Ring has not previously been utilized for such extensive applications. By incorporating Ring, the second generation of PWCT aims to offer a useful tool for Ring developers while also validating Ring’s effectiveness in handling projects on a scale similar to PWCT2 [29,30].
Therefore, the primary aim of this work, as demonstrated in Figure 3, is to use the Ring programming language to develop a research prototype for the second generation of the PWCT visual programming language. PWCT2 offers several enhanced features, including a more flexible environment, time dimension and auto-run, rich colors and customization, rich comments using text, lines, images, and HTML, an enhanced form designer for GUI applications, support for importing Ring source code and interactive textual-to-visual code conversion, self-hosting of the PWCT2 environment, and cross-platform implementation that supports Windows, Linux, and macOS. These features aim to improve the overall functionality, user experience, and performance of the PWCT2 environment.
The main contributions of this study are:
The design and implementation of the research prototype PWCT2, which offers enhanced features, lower storage requirements for visual source files, and better code generation performance compared to the first generation.
The design and implementation of the first VPL that supports code generation in the Ring language (RingPWCT), containing 394 visual components. This integrates visual programming with the flexibility of the Ring language.
The design and implementation of a textual-to-visual code conversion tool called Ring2PWCT that can import Ring programming language code. Using this tool enables a self-hosting VPL based on Ring.
Testing the feasibility of using the Ring programming language compiler and virtual machine in the development of projects on a scale similar to PWCT2.
The remainder of this paper is structured as follows: Section 2 delves into related work. Section 3 describes the materials, methods, and the proposed visual programming language. In Section 4, the results and evaluation of the visual programming language are presented. Section 5 includes the discussion. Lastly, Section 6 provides concluding remarks and outlines future work.
2. Related Work
Languages like Visual Basic and Visual C# fall into the category of textual programming languages, not visual programming languages (VPLs). Programmers need to write text-based code using the specific syntax of these languages to develop large and complex real-world applications. Tools like Microsoft Visual Studio 2022 are known as integrated development environments (IDEs) rather than VPLs. These environments allow software developers to create portions of applications using visual elements, but textual code is essential to achieve full control over the application’s functionality. In contrast, VPLs rely exclusively on visual components without the need to write textual code directly. In text-based programming languages like C++ and Java, the code is linear and one-dimensional, with the compiler processing it token by token. In contrast, VPLs utilize graphical representations that span multiple dimensions. Each graphical element occupies a specific position within a 2D or 3D space and can have unique shapes, colors, and images. Various relationships can be depicted between these objects, such as being inside, outside, touching, or adjacent to one another. Additionally, some visual languages incorporate the time dimension (before/after) to further enhance the graphical code representation [4,31].
A visual programming language can have several different representations. One option is diagrammatic, which uses shapes and text components with links to connect shapes and illustrate control or data flow. Another representation is iconic, which utilizes icons derived from the problem’s domain. There are also form-based representations that incorporate forms like spreadsheets or data-entry forms and block-based representations that feature blocks assembled to form programs. Additionally, a VPL can be hybrid, combining elements of any of these four representations [32,33].
The design of the proposed visual programming language is associated with various categories of VPLs. In Table 1, we present some of the different categories based on their visual representations or usage scope, along with examples of visual programming languages that fit within them. It is worth noting that some VPLs can be classified into more than one category. For instance, Scratch could fall into both the first and fifth categories, as it is a visual programming language that uses block-based programming and is designed for use in education and teaching children about programming.
In Table 2, we present the key features of our proposed visual programming language and its connections to some other visual programming languages from different categories. As we compare these visual languages, if a feature is absent but available through external ongoing projects, we denote it with a (star) in the corresponding cell.
We selected Scratch because it is a popular VPL for education that uses blocks-based programming. Forms/3 is chosen as an example of form-based and spreadsheet-like programming, with support for the time dimension. Lava is included because it is a VPL that uses the TreeView control and supports object-oriented programming (OOP). Envision is selected as a research prototype for a general-purpose VPL that features interactive visualizations. Finally, PWCT is chosen because it is a general-purpose VPL used in advanced projects, such as developing the Ring programming language.
In the efforts made by the researchers to make Envision a self-hosting programming environment, significant strides were achieved. A code generation framework was designed and implemented to represent macros in Envision when importing code from C++. Additionally, an extra stage in the existing C++ import system was developed to facilitate macro import by reconstructing them from expanded code using preprocessor information from Clang. Although the authors reported that time constraints and issues in existing components prevented the complete achievement of the goal, it is important to note that using C++ for Envision implementation introduces some challenges in implementing a self-hosting VPL because of the numerous features and preprocessor usage [28].
Multiple research studies highlight the importance of ensuring the construction of correct programs through visual programming languages. This addresses key aspects of program correctness and reliability, which are critical for enhancing both usability and the practical effectiveness of visual programming environments. PWCT provides two modes of operation. The first mode follows the concept of a syntax-directed editor and prevents composition errors when connecting components. The second mode uses a free editor where mistakes can occur and are then detected by the compiler. In PWCT2, the visual editor prevents composition errors, and the user can use the customization window to allow or disallow errors when typing expressions in the interaction page [57,58].
The first generation of PWCT is influenced by Lava 0.7.2 (using a TreeView control to represent the program structure) and Forms/3 (using the Time Dimension). It introduces new features like the Graphical Code Replacement (GCR) method (instead of drag-and-drop) and playing programs as a movie using the Time Dimension. The proposed visual programming language (PWCT2) builds on PWCT by incorporating the GCR method, Steps Tree, Time Dimension, and playing programs as a movie. It also draws inspiration from Scratch, incorporating rich colors and block-level drag-and-drop support. Additionally, PWCT2 is influenced by the Envision visual programming system, enabling rich comments and supporting interactive visualization.
The proposed VPL is implemented using the Ring language, supports Ring code generation, and enables importing Ring code, making it a self-hosting VPL. These capabilities are particularly important in the age of large language models (LLMs) and code generation, as they enable the use of LLMs to generate Ring code that can be used in PWCT2 and updated using visual programming. Since Forms/3, Lava, and Envision are no longer under active development, and while Scratch is actively developed, it is domain-specific, and PWCT, though general-purpose, is designed for MS-Windows, we expect that the proposed VPL, with its support for multiple platforms and modern features, could be a valuable addition to the landscape of VPLs. It could be especially useful for Ring programmers or novice programmers who want to learn about the Ring language through visual programming, as this proposed VPL is the first to support the Ring programming language.
While visual tools such as Blockly 2022 and Node-RED 4.0.2 are very popular and serve as the foundation for many visual programming languages, we believe that the PWCT2 approach and its interactive textual-to-visual code conversion offer notable flexibility. This could attract more users with coding backgrounds to try the PWCT2 visual programming approach. Additionally, such features could influence future updates to Blockly and Node-RED if more users find them useful and necessary [12,13,59,60].
No-code platforms provide highly intuitive drag-and-drop interfaces and prioritize rapid development, allowing non-technical users to quickly build entire applications without any coding knowledge. These tools simplify the development process for specific application types, making them accessible to a wider audience. While visual programming languages (VPLs) provide a visual approach to traditional programming [61,62].
Both PWCT2 and no-code development tools aim to simplify the creation and development of software and applications, but they serve different needs. For example, PWCT2 focuses on making traditional coding more accessible by providing flexibility and customization for a wide range of applications. Through further development, the PWCT2 visual programming language can act as an intermediate-level abstraction layer between traditional coding and no-code. General-purpose visual programming languages like PWCT2 can be used as the foundation for building no-code platforms, enabling higher levels of abstraction and ease of use while maintaining full control through visual programming.
3. Materials and Methods
In this section, we describe our system design and implementation. We highlight the important features of the proposed visual programming language, PWCT2, and present the system architecture, which is implemented using the Ring programming language version 1.22.
3.1. Implementation Using the Ring Language
The architecture of the proposed visual programming language (shown in Figure 4) is divided into three main layers: Use Cases, PWCT Environment, and Ring Language. Each layer contains specific components that contribute to the overall functionality of the system. The bottommost layer, Ring Language, includes Development Tools, Libraries, Compiler, and Virtual Machine (VM). Development Tools provide various tools that assist in the development process, such as the package manager and Ring2EXE. Libraries consist of pre-written code libraries that developers can use to add functionality to their programs, saving time and effort by providing reusable code for common tasks. The compiler processes Ring textual source code and generates bytecode for the Ring Virtual Machine if the program is correct. If there are issues, it produces compile-time errors. The Virtual Machine (VM) provides a runtime environment for the programs written in Ring, executing the compiled code and managing the program’s execution [23,30].
The middle layer, PWCT Environment, consists of Visual Programming, the Ring to PWCT converter, and the File System (Visual Source). Visual Programming allows developers to create programs using visual elements rather than traditional text-based code, providing a more user-friendly development experience. This is achieved through tools such as the Steps Tree editor, time machine, components browser, interaction pages (data-entry forms), and form designer. The Ring to PWCT converter assists in importing the textual source code written in Ring and visualizing the structure and flow of the program by offering graphical representations of the program’s logic. This enables us to continue program development using visual programming instead of relying on the textual source code. The File System (Visual Source) manages the visual source files within the PWCT environment, organizing and storing information about the visual elements used in the development process. PWCT can generate Ring source code from these visual source files, enabling the execution of these programs using the Ring compiler and virtual machine.
The topmost layer, Use Cases, includes the various applications and 2D games that can be developed using PWCT based on the Ring programming language, ranging from simple utilities to complex software solutions. Overall, the architecture of the proposed system is designed to provide a comprehensive and user-friendly environment for visual programming based on the Ring programming language, making it accessible to both novice and experienced Ring developers.
3.2. Flexible Visual Environment
In this section, we introduce the design differences between PWCT1 (the first generation of Programming Without Coding Technology) and PWCT2 (the proposed new generation). In the first generation of PWCT, visual programming is achieved through four sub-systems: Goal Designer, Components Browser, Interaction Pages, and Form Designer. The Goal Designer is used for designing modules and provides the Steps Tree Editor and the Time Machine. The Components Browser enables users to select specific components, each offering one or more interaction pages (data-entry forms). Entering data into these interaction pages generates or updates steps managed by the Goal Designer [16,17].
3.2.1. Single Main Window and Several Dockable Windows
In PWCT1 [17], the visual programming sub-systems are not designed to be used simultaneously on one screen; each sub-system uses a separate window. For instance, the Goal Designer and Components Browser, or the Components Browser and Interaction Pages, cannot be viewed at the same time. In the proposed visual programming language PWCT2, this design has been revised to use a single main window for all sub-systems, as shown in Figure 5. Each sub-system now occupies a separate dockable window [63,64], allowing users to view all sub-systems simultaneously, which avoids the complete redrawing of the screen when switching from one to another. We also added two dockable windows: one for Project Files, where users can quickly navigate to specific folders and open visual source files, and another for the Output window, where users can see the program output, send input to the running program, or terminate it at any time.
The previous generation of PWCT did not provide these features (project files/output window) and relied on operating system dialog boxes to open files and the command prompt window to display program outputs [21]. Another feature added by PWCT2, which does not exist in PWCT1, is the ability to open multiple interaction pages simultaneously. This simplifies the process of reading and updating programs. The Steps Tree Editor provides a feature to open all of the interaction pages at once through a keyboard shortcut.
The program illustrated in Figure 5 is a simple example that prints two lines of text: “Hello, World!” and “Welcome to PWCT2”. The proposed visual programming language makes it straightforward to create and modify the program visually. Users can add, remove, or change steps by interacting with the Steps Tree and the Print Component. For instance, to change the text being printed, users can simply edit the text in the Print Component interaction page and click “Ok”. Additionally, new steps can be added by selecting the desired components from the Components Browser.
The Components Browser (left panel) lists various visual components that can be used in the program. These components belong to the RingPWCT visual programming language. Categories include Comments, Templates, Console, Control Structures, and more. Each category contains specific components, such as “Print Text”, “Get Input”, “The If Statement”, and “For Loop”. We can find and select a component using the mouse or through a search process by the component name or part of the name.
The Steps Tree (middle panel) displays the structure of the program in a hierarchical tree format. The program starts with a “Start Point” and includes steps generated by the Basic Program component, such as “The First Step”, “Load Files”, “Statements”, “Functions”, and “Classes”. Using the Basic Program component is optional, and these generated steps are just comments for organization. Additionally, there are steps generated by the Print Text component, like “Print Hello, World! (New Line)” and “Print Welcome to PWCT2 (New Line)”. In general, each step represents a specific action or command in the program, or it could be just a comment to provide a better understanding of what the program does or its structure.
3.2.2. Flexible Steps Tree Editor
The Steps Tree editor in PWCT2 is designed for flexibility and provides many features that do not exist in PWCT1, including drag-and-drop functionality to move steps from one location to another instead of using cut and paste. This enhanced flexibility significantly improves the user experience by simplifying the process of organizing and modifying steps. In PWCT1, when we add a step as a child to another step, the parent step must be of a type that allows children, and the added step will be at the end of the children. This is a limitation if we want to insert a new step between two other children, requiring the steps to be added first and then moved to the desired location.
In PWCT2, the insertion process is supported, where selecting a step that does not support children and then adding a new step inserts it after the selected step. This change enhances the capability to modify the program’s structure on the fly, making development more intuitive.
The Steps Tree editor provides common features expected from editors, such as Find and Replace, Go-To, and Print to PDF, ensuring that users have access to essential editing tools. In Figure 6, we demonstrate how to insert steps between other steps by inserting the “Print TWO (New Line)” step between the steps that print the “ONE” and “THREE” messages on the screen. In the second section of the figure, we show how to use the Find and Replace window to find steps that contain specific text. These improvements collectively contribute to a more user-friendly development environment.
3.2.3. RingPWCT Components in the Components Browser
In PWCT1 [17], the environment includes multiple visual programming languages, such as HarbourPWCT, CPWCT, PythonPWCT, and SupernovaPWCT. Each visual language comes with a group of components classified into different domains, generating textual source code in specific textual programming languages like Harbour, C, Python, and Supernova. In our research prototype of PWCT2, we focus on supporting the Ring programming language through the RingPWCT visual programming language, which provides visual components that generate textual source code in the Ring programming language. Table 3 provides an overview of the 394 visual components available in the RingPWCT visual programming language within PWCT2.
The table categorizes the components into different domains, specifying the number of components in each domain and providing an example for each domain. For instance, the General domain includes six components, with “Quick Start” as an example, while the Console domain comprises four components, with “Print Text” being one of them. Other notable domains include Control Structures, with 13 components like “For-In Loop”, and GUI, which has the highest count of 88 components, exemplified by the “Window Class”. The table also highlights various other domains such as Functions, Program Structure, Lists, Strings, Date and Time, and Math, among others. Each domain contains a specific number of components tailored to different programming tasks. For example, the Date and Time domain includes seven components like “Add Days”, while the Database domain, one of the most extensive, contains 34 components such as “ODBC Connect”. This comprehensive categorization helps users navigate and utilize the diverse set of tools available in RingPWCT to enhance their programming experience within PWCT2.
3.2.4. Advanced Visual Components and Templates
In PWCT1 [21], visual components are based on a specific scripting language designed for the PWCT environment. This scripting language is intended to be easy to use and increase productivity by providing specific commands that guide the steps generation process based on data entered in the interaction pages. However, this scripting language is very limited and provides simple concepts related to variables, if-statements, steps/code generation, and rules for relationships between components. It does not have loops, functions, or the ability to be extended without modifying its interpreter [65].
These limitations prevent the development of rich and powerful components that could perform advanced tasks during steps generation. Components are designed under the assumption that the component generating the steps will also be responsible for updating these steps. In other words, a component cannot generate steps that belong to other components. For example, to create a template of steps that belong to different components, a specific visual source file with these generated steps must be created. The user can then start a new visual source file from these templates. This means that these templates must be used at the start of creating new visual source files, and multiple templates cannot be used in the same visual source file without creating a new template that integrates them.
PWCT1 uses two different programming languages: Visual FoxPro for developing the PWCT environment and a scripting language called RPWI designed for developing visual components. In the proposed visual programming language (PWCT2), the Ring textual programming language is used for developing both the PWCT2 environment and the visual components. Using Ring for developing the environment components enables us to create advanced components and avoids the known limitations of RPWI. For example, we have the Quick Start component, which can be used to generate steps that belong to multiple components, as shown in Figure 7.
The Quick Start component contains many templates that we can use. One of these templates is the Modify Lists Using Loop template. Selecting this template generates multiple steps that belong to different visual components, such as the For In component, Switch component, Case component, etc. The Quick Start component can also generate comments and provides a No Comments checkbox to avoid generating comments if desired.
3.3. Time Dimension and Auto-Run
In PWCT1, users can use the Time Machine to change the time position and go backward in time to see the program at a specific point in the past and check the order of steps added to the program. We also have the option to play the program as a movie and see how the visual components are used step by step to create the program. Additionally, we can run the program at a specific point in the past and see the program output at that point. In PWCT2, we support the Auto-Run feature as shown in Figure 8, where changing the time position or adding new steps to the program will directly execute the program and display the output in the output window.
The program contains a for-loop and a conditional statement. The first position in the figure shows the initial state with a For loop running from x = 1 to 10 with a step of 1 and an If statement checking if x equals 3. The second position captures the execution of the If statement when x equals 3, printing “Three” on a new line. The third position demonstrates the continuation of the loop, printing the value of x on a new line for each iteration. The output on the right side of the third screenshot lists the numbers 1 to 10, with “Three” replacing the number 3, highlighting the effect of the conditional statement.
3.4. Rich Colors and Customization
Unlike PWCT1, which provides one style for the environment (White Style), PWCT2 enables us to select the PWCT environment style (White, Dark, Blue, etc.). Like in PWCT1, we have a Customization window to determine the colors used in the Steps Tree editor based on the step type (see Table 4). Each visual component can generate one or more steps in the Steps Tree after entering the required data on the interaction page. These generated steps might belong to the same component or be related to other components if the original component is a template. We can use the same component again by clicking the ‘Again’ button on the interaction page.
PWCT2 can use multiple colors in each step to highlight the data entered by the user from the text generated by the visual component, whereas PWCT1 uses one text color and one background color per step. This improvement is inspired by Scratch [66]. Additionally, we can show or hide the dockable windows as needed. As shown in Figure 9, we focus on the Steps Tree editor and interaction pages after setting the style to Dark and customizing the Steps Tree colors using the Customization window.
Additionally, the Customization window enables us to set the Steps Tree background color and adjust the indentation level in the Steps Tree. In the Options tab, we also have advanced options that can enable the Auto-Run feature and control the environment’s behavior in different situations, such as opening the interaction pages in the Steps Tree dockable window or in separate windows.
In PWCT1 [21], users can open only one visual source file at a time for each instance of PWCT1. Opening multiple visual source files simultaneously requires running multiple instances of PWCT1. In PWCT2, we have the Project Files dockable window, as shown in Figure 10, where we can easily select and open any visual source file or form file. Additionally, using the options in the Customization window, we can choose to open files in new tabs, allowing us to work with and view multiple files simultaneously. This improvement is inspired by popular editors and IDEs like Visual Studio and NetBeans [67,68].
The Customization window is open in the center, displaying two tabs: “Colors” and “Options”. The “Options” tab is selected, showing a list of customization options with checkboxes. The options listed in the Customization Window include Auto Run, Open files in new tabs, Show the Time Machine options, Steps Tree—Hide Step Code Tab, Show Steps Tree Lines, Light Tree Lines, Steps Tree—Show Nodes Icon, Open interaction pages in new windows, Allow Syntax Errors in Interaction Pages, Avoid Components Browser, Avoid Components Browser Auto-Complete, Components Browser—Always Show Search Window, Reflect changes in font size to other windows, and Borders around steps (in supported styles).
For projects with many files, we have the option of a Main File (available in the toolbar), which we can run at any time to start the project, even if we are focusing on another sub-file within the project. Switching between files is easy using tabs that include the file name and are located at the bottom of the window. We can also view two files side by side in the PWCT2 environment by moving the dockable window of the file.
On the left side, there is a “Project Files” dockable window displaying a list of files and folders related to a project named “GoldMagic800”, which is a puzzle game that contains 44 levels [69]. The highlighted file is “gamebase.pwct”. In the center, there is a “Steps Tree” dockable window showing a hierarchical list of methods under the “Class GameBase”. On the right side, there are interaction pages for defining function components, if-statement components, assignment components, and class components. The user can determine which interaction pages to open simultaneously and use them to generate new steps and create programs without having to switch back to the components browser.
3.5. Rich Comments Using Text, Lines, Images, and HTML
PWCT1 [21] enables adding comments to our Steps Tree, referred to as “user steps”, which use text to describe something or add information about the program. In PWCT2, we use different types of comments, not just text. We can add lines, images, and headers with specific fonts and colors. In Figure 11, we have a program that uses a Raspberry Pi Pico to control an LED, making it blink, with the ability to interact using a switch [70]. Using rich comments, we added a header that represents the sample title, followed by a horizontal line, and then an image of the circuit. Comments could include HTML, as demonstrated in Figure 12. This feature could be used for adding tables from both local and online web pages to our program. This improvement is inspired by the Envision visual programming system [27].
3.6. Enhanced Form Designer for GUI Apps
The Form Designer is a tool that simplifies the process of creating user interfaces by allowing users to easily add UI controls to the form, adjust properties, and define events such as click actions for buttons. In PWCT1, the Form Designer, used for GUI applications, differs from popular form designers like those in Visual Studio. Instead of using a Toolbox and Properties window, the PWCT1 Form Designer utilizes the Components Browser and Interaction Pages, making it tightly integrated with the Goal Designer and not suitable for use as an external tool [71].
In PWCT2, we revised this design and provided a reusable Form Designer, which is successfully used in both PWCT2 and Ring Notepad (the IDE provided by the Ring programming language). In PWCT2, the Form Designer uses the Model-View-Controller (MVC) design pattern [72,73,74].
The Form Designer, as shown in Figure 13, allows users to visually design the user interface of their application. It includes the Toolbox, Form Layout, and Properties Panel. The Toolbox contains various UI elements, like labels, buttons, text edits, checkboxes, etc., that can be added to the form. The Form Layout is the main area where UI elements are placed. For example, in the figure, we notice it includes UI controls such as Title, Author, Abstract, and Output. This layout is related to an application that predicts the citation count of research papers in the field of Otology. The Properties Panel shows the properties of the selected object (e.g., a button named btnSelect). Properties include Name, Position (X and Y), Size (Width and Height), Text Color, Background Color, Font, Text, Image, and Click Event.
The Steps Tree (left panel) displays a hierarchical view of the steps involved in the Controller visual source file, including importing the System.GUI package, checking if the file is the main source file, creating and accessing objects, defining the class, and more. The New Object Component (top middle panel) allows users to create a new object from a specific class. The Access Object Component (middle panel) is used to access an existing object within the program and allows us to use the object’s attributes and methods. The Call Method Component (bottom middle panel) is used to call a specific method supported by a specific object.
3.7. Interactive Textual-to-Visual Code Conversion
PWCT2 comes with a feature called interactive Textual-to-Visual code conversion, as demonstrated in Figure 14. The first section of the image illustrates the user writing Ring code, showcasing the textual input of programming constructs. In this section, the code creates an object from the point class, sets the object’s attributes, and defines the point class using the Ring programming language. In the second section, this Ring code is automatically converted into a visual representation using Ring2PWCT. The visual interface displays the code elements as graphical components, arranged in a logical flow that mirrors the structure of the original Ring code. This conversion allows users to interact with and manipulate the program visually, making it easier to understand, modify, and debug without delving into textual syntax. The transition from text to visual representation bridges the gap between textual programming and visual programming, enhancing the user’s experience and productivity.
To start using this feature, it is sufficient for the keyboard Focus to be active at the Steps Tree at any step. Once the user starts typing, the components browser will be activated, where PWCT2 expects that the user is searching for a visual component to use. If the visual component does not exist, PWCT2 expects that the user will type Ring source code and highlight this code. If the user presses ENTER, PWCT2 will then use Ring2PWCT to generate the visual representation. The generated steps will be inserted into the selected location in the Steps Tree, enabling us to use this feature at any location in our program.
This feature can be used to mix textual programming (for writability) and visual programming (for readability) in the same project [75,76]. Additionally, the code could be generated using large language models (LLMs) such as Copilot [77] as demonstrated in Table 5. Furthermore, this feature enables us to import current projects written in Ring so that we can continue developing them using PWCT2.
The implementation of Ring2PWCT involves some of the same phases as compiling, such as scanning and parsing [78,79]. Instead of low-level code generation, we generate a visual source file. Alternatively, it can update the current file if Ring2PWCT is used to insert steps into the existing visual source file instead of creating a new one. Ring2PWCT is generally considered a form of translation, specifically source-to-source translation, because it converts source code from one high-level language to another (in this case, from Ring code to PWCT visual code) [80]. Ring2PWCT is designed to pass errors when possible. For example, using the Ring code (for x = 1 to 10 if x = 3 ? “Three”) as input can be converted to visual code (similar to the first section in Figure 8), even if keywords such as EndFor and EndIf are missing.
3.8. Self-Hosting the PWCT2 Environment
PWCT1 is developed using Visual FoxPro, where enhancing the development environment requires using VFP textual code. Although the environment includes a domain-specific language (RPWI) for visual component development, it remains textual code, and using visual programming to improve PWCT1 itself is not supported. Therefore, self-hosting PWCT2 could be an attractive feature because it allows the development and customization of the PWCT2 environment using its own visual programming tools. This approach enables us to improve and refine PWCT2 through visual programming instead of traditional textual coding, making the process more user-friendly and accessible, as shown in Table 6, which demonstrates converting a class from textual code to visual code.
While PWCT2 is designed to support interactive textual-to-visual code conversion, this feature is intended to be used within the PWCT environment inside the Steps Tree Editor. Based on this feature, we developed a command-line tool that can take a Ring source file as input and produce a visual source file as output. Since PWCT2 and its visual components are written in Ring, we used this tool (Ring2PWCT) to convert the PWCT2 source code files from Ring to visual source files, allowing us to use PWCT2 to continue developing itself. In Table 6, we present an example of using Ring2PWCT to convert one of the source code files related to the PWCT2 implementation using the Ring language. This file contains the View class for the (Print Text) visual component. This class inherits from the ComponentViewParent class, which contains common attributes and methods useful for developing new visual components inside PWCT2.
3.9. Cross-Platform and Faster Implementation
PWCT1 was developed as a Microsoft Windows product, with no native support for other operating systems like Linux and macOS. Additionally, PWCT1 is 32-bit software. Since PWCT2 is developed using the Ring programming language, which is a lightweight, versatile, and cross-platform language, it was possible to create a cross-platform and 64-bit version of PWCT2 based on Ring and the Qt framework, supported by the RingQt extension. In Table 7, we present the modules, along with the count of files and lines of code. Figure 15 demonstrates using PWCT2 on macOS to develop the Tetris game using the Ring game engine for 2D games, which is based on the Allegro game programming library [81,82]. The game engine provides classes that can be used to quickly prototype simple 2D games. These classes include Game, Text, Sprite, Animate, Map, etc.
The PWCT2 project is one of the early advanced projects developed using Ring (see Figure 16). The Environment module provides the main window and creates the different dockable widgets. The General Functions module encompasses general functions required by the software. The Translation module handles various translation functions. The Goal Designer modules contain the Steps Tree Editor and the Time Machine. The Components Browser allows users to navigate through available components and select a component to use.
The VPL Components module, being the largest, includes all the RingPWCT visual programming language components necessary for creating and managing programs. The Component module provides the foundational elements required for the different visual components, including interaction pages and generating visual steps. The Form Designer module provides functionality for designing forms within the environment. The File System module manages the visual source files. Finally, the Tools module contains various utilities, including the textual-to-visual code converter (Ring2PWCT).
During the development of PWCT2, we made specific design decisions that resulted in improved performance compared to PWCT1. These design decisions helped enhance various aspects of PWCT2, with notable improvements in code generation time and storage requirements for the visual source files.
These design decisions are as follows:
The Steps Tree is stored in the visual source files in the correct order of control flow, with PWCT2 adding steps at the end of the file or inserting them based on their actual position. In contrast, PWCT1 always adds new steps at the end of the file, requiring the Steps Tree to be ordered during the code generation process.
Storing the visual source in memory through Ring Lists during development and saving to storage only when needed, instead of using database files and storage on the hard disk during development as in PWCT1. It is known that accessing computer memory is faster than accessing the hard disk drive.
Using the Ring programming language instead of Visual FoxPro. Since Ring development is active, the latest versions of the Ring Compiler/VM are produced using the latest versions of C/C++ compilers, which also benefit from the performance improvements in these tools.
Using the Qt framework for the GUI environment through RingQt. The framework is written in C++ and provides better performance with each update and direct support for the TreeView control instead of using ActiveX control as in PWCT1.
4. Results
The development of the software started in October 2016, the same year the Ring programming language was released. The development continued slowly, with more time invested in improving the Ring language itself, enhancing its stability, performance, and libraries. PWCT2 was released on the Steam platform in March 2023, based on Ring 1.17, and has received continuous updates based on community feedback [83]. We also keep updating the Ring version included in the software after each Ring release. The current version of the software is PWCT 2.0 Rev. 2025.01.20, which is based on Ring 1.22. In this section, we present the various results related to our study. First, we explore a variety of use cases. Subsequently, we examine our observations regarding the implementation of PWCT2 using the Ring language. Furthermore, we discuss the performance metrics of PWCT2. Finally, we provide details about download numbers, usage time, and user feedback.
4.1. Use Cases
The primary use case for the PWCT2 software is as an alternative to the Ring Code Editor, allowing users to create new projects based on Ring or to import and update/execute Ring programs instead of using Ring Notepad. Ring2PWCT plays a significant role in this process, while the Time Machine feature enables users to read the program step by step and run it from a previous point in time. This functionality facilitates the continued development and maintenance of numerous Ring samples and applications.
In Figure 17, we introduce the SuperMan game, which is distributed with the Ring language. Using PWCT2, it was possible to import the game implementation and check it step by step. The game is based on the Ring game engine, which is designed for developing simple 2D games. PWCT2 comes with many samples related to game programming libraries like Allegro, RayLib, and Tilengine. These samples are converted from the Ring programming language project to PWCT2 through the Ring2PWCT tool, which converts Ring textual code to a PWCT2 visual source file.
Since PWCT2 comes with a Form Designer and the required visual components to build GUI applications, it was possible to use it in developing multiple GUI applications, including an application to predict citation counts in the Otology field using the research paper title, author, and abstract [84]. In the Citations Prediction application, the user interface is designed using the PWCT2 Form Designer (the same designer provided by the Ring language), and the application logic is designed using PWCT2 before generating Ring code. The application receives input from the user and submits it to the machine learning model through the internet using the LibCurl library. The models are developed using Microsoft Azure Machine Learning. The 394 visual components provided by RingPWCT and introduced in Table 3 offer sufficient features to develop such applications.
In Figure 18, we demonstrate the Azure class used by the Citations Prediction application to connect to the Machine Learning model. This class could submit the research paper title, authors, or abstract as input to the model and receives the predicted citation count as output. Different machine learning models are utilized based on the selected input. The class contains the web service URL and the API key as attributes. Within the same project, in addition to the azure.pwct file, there are other files, such as sysdata.pwct, which includes some research paper samples. There are two form designer files: dataset.rform and predict.rform. The first file provides a table to select a research paper from the available samples. The second form is the main form of our application and allows users to enter the paper information to be used as input for the model and includes a button to open the other form in the dataset.rform file. These forms respond to GUI events that are handled by the files datasetController.pwct and predictController.pwct. When we open a form file using the project files window, PWCT2 will automatically open the corresponding visual source file for the controller class.
Another known application in the Ring language community that is developed using PWCT2 is the Find in Files application, which is distributed with Ring Notepad [23]. The application is shown in Figure 19. The application’s user interface is developed using the form designer and utilizes Qt layouts to automatically resize the controls.
The Find in Files application supports search, replace, and replace all operations on one or more files. During a search operation, the user can enable the (Match Case) checkbox to perform a case-sensitive search. Using the (Browse) button, the user can select a specific folder to be used when searching for files. The application utilizes visual components related to file and text processing, as shown in Figure 20. The (Read File) component receives two parameters: the (File) variable, which contains the file name to read, and the (Output) variable, which contains the file content as a string. The (String to List) component converts a Ring string to a Ring list that can be processed using list functions. Each list item will contain one line of text and can be processed using string processing components. For more efficient and high-performance implementation, it is recommended to avoid converting the string to a list since the string can be processed directly.
4.2. Implementation of PWCT2 with the Ring Language
The implementation of PWCT2 using Ring involves using the language compiler, virtual machine, libraries, and tools. Ring 1.17 was sufficient to release the PWCT2 software on the Steam platform in 2023, but we found the language features and stability more satisfactory starting from Ring 1.19, where Ring 1.18 improved support for references and Ring 1.19 improved performance. Later versions released in 2024, such as Ring 1.20, Ring 1.21, and Ring 1.22, provided additional features, stability, and performance improvements. In Table 8, we list information about the project size, including dependencies such as the standard library and the GUI library from Ring 1.22.
In Table 9, we present the compile-time using different versions of the Ring language, the size of the generated Ring VM byte-code instructions, and the size of the generated Ring object file (default size and compressed size). The tests are done using a Victus Laptop [13th Gen Intel(R) Core(TM) i7-13700H, Windows 11].
The data show a substantial reduction in compile-time from 1480 milliseconds in Ring 1.17 to 871 milliseconds in Ring 1.22 (see Figure 21), highlighting significant enhancements in the compilation process.
There is a notable decrease in the number of byte-code instructions from 900,113 in Ring 1.17 to 724,382 in Ring 1.22 (see Figure 22), indicating more efficient bytecode generation. We can compile the PWCT2 project to a Ring object file, which can be run directly using the Ring Virtual Machine without the need to compile the project again using the Ring compiler. The size of the Ring object file initially increased slightly but then decreased significantly (see Figure 23) to 18,952 KB in Ring 1.22, reflecting optimization improvements.
The compressed object file size remained relatively stable. Compressing the object file and reducing the required storage could be useful when distributing the project over the internet. However, the real size of the object file (without compression) matters because the Ring Virtual Machine processes and loads this file into memory when running the project. These results collectively illustrate the progress achieved with the subsequent versions of the Ring language.
4.3. PWCT2 Performance
Table 10 presents performance results related to the PWCT2 environment, showcasing various visual source files and their corresponding metrics. These files represent games and utilities such as StopWatch, Snake, Matching, Sokoban, Escape, Tessera, FlappyBird3000, and others. Each sample is evaluated based on several criteria: file storage in kilobytes (KB), the number of visual components, steps involved, generated lines of code (LOC), loading time (LT) in milliseconds required to display the visual representation, and code generation time (CGT) in milliseconds. The data demonstrate a range of sample complexities, with file storage sizes varying from 41 KB to over 1000 KB, and visual components ranging from 40 to 1269. The number of steps and lines of code also vary significantly, highlighting the diverse nature of these visual source files. Loading and code generation times provide insights into the performance efficiency of PWCT2 across different applications. The measurements are done using a Victus Laptop [13th Gen Intel(R) Core(TM) i7-13700H, Windows 11, PWCT 2.0].
In Figure 24, we present the relationship between the number of steps and the required storage. The figure is a stacked bar chart comparing the storage (in KB) and steps for various applications or games developed using PWCT2. The x-axis lists the names of the applications/games, while the y-axis represents the values for storage and steps. The blue segments of the bars represent storage, and the orange segments represent the number of steps in the visual source file.
In Figure 25, we present the relationship between the number of visual components and the generated source code, showing that using visual components increases the abstraction level. In Figure 26, we demonstrate the relationship between both the loading time/code generation time and the step count in the visual source file.
We notice from Figure 26 that the loading time increases significantly as the file size and complexity grow, with a noticeable spike around the 600 ms mark, indicating that more complex files require more time to load. The orange line represents the code generation time, which remains relatively low throughout the different samples, with only minor fluctuations. The code generation time is more critical for developers because they may need to run the program multiple times during development and updating the visual code, making it essential to keep this time low for a smoother and more efficient development cycle. On the other hand, the loading time, while important, is typically incurred only once per file. By maintaining consistently low code generation time, PWCT2 enhances the development experience, making it more efficient and less time-consuming for developers.
Table 11 demonstrates the performance and storage requirements of PWCT2 and PWCT1 [23] when using visual source files that contain at least 1000 steps by evaluating various metrics: file storage in kilobytes (KB), the number of steps, loading time (LT) in milliseconds (ms), and code generation time (CGT) in milliseconds (ms). These visual source files pertain to different visual programming languages (CPWCT vs. RingPWCT) and various programs. However, the step counts fall within the same range, representing the size of the visual programs, which influences the code generation performance and storage requirements. PWCT2 shows significant improvements in file storage efficiency and code generation time, with much smaller file sizes (773 KB to 1012 KB) and faster code generation (43 ms to 52 ms) compared to PWCT1, which has larger file sizes (7966 KB to 11,397 KB) and much longer code generation times (1748 ms to 3862 ms). Although PWCT2 has higher loading times for the visual source files (1068 ms to 1270 ms) than PWCT1 (549 ms to 860 ms), this difference is not substantial and is due to new optional features in PWCT2, such as rich colors where the same steps can use more than one color. The faster code generation time in PWCT2 is crucial for developers who need to run the program multiple times during development, making it more efficient and less time-consuming.
In Table 12, we present a summary of the key statistical metrics derived from analyzing the relationship between the number of steps, storage requirements, and code generation time (CGT). The analysis for PWCT2 is done for 25 visual source files presented in Table 11 which used RingPWCT. The analysis for PWCT1 is done for 43 visual source files related to CPWCT and introduced in the literature with storage size and code generation time [23].
We used the same hardware for all experiments. Also, to ensure the reliability and validity of our findings, we calculated the p-values for both Pearson and Spearman correlation coefficients across storage vs. steps and code generation time vs. steps. This statistical analysis allowed us to determine the significance of the observed relationships. By verifying that the p-values were well below the accepted threshold of 0.05.
For PWCT2, our analysis revealed a very strong positive correlation between the number of steps and both storage and code generation time. This indicates that as the number of steps increases, both storage and CGT also increase in a nearly linear fashion. The average storage required per step was found to be 0.6543 KB, while the average CGT per step was 0.0353 milliseconds. Furthermore, the Root Mean Square Error (RMSE) values for storage per step (0.1082) and CGT per step (0.0032) were low, suggesting that the average values are reliable and well represented by the data. These findings demonstrate the efficiency and scalability of code generation in PWCT2, particularly in handling visual source files with a high number of steps.
For PWCT1, the average storage required per step was found to be 13.6751 KB, while the average CGT per step was 1.2956 milliseconds. Furthermore, the Root Mean Square Error (RMSE) values for storage per step (23.4063) and CGT per step (1.0539) were calculated, indicating some variability around the averages. Despite this variability, the correlations remain strong and statistically significant, underscoring the reliability of the data and the performance characteristics of PWCT1. These findings highlight the substantial resource demands of code generation in PWCT1, particularly as the number of steps increases.
The statistically significant data and strong performance metrics allow us to generalize the findings when discussing the performance improvements of PWCT2 over PWCT1. On average, PWCT2 is approximately 36.7 times faster in code generation time (CGT) per step and uses approximately 20.9 times less storage per step compared to PWCT1. This significant improvement is evidenced by the lower average CGT and storage per step for PWCT2, as well as the low RMSE values, indicating high efficiency and consistency. These results highlight the advancements and effectiveness of PWCT2, making it a more efficient tool for visual programming tasks.
4.4. User Feedback
Once we started distributing the software and describing it as a visual programming tool and a replacement for the Ring Code Editor, users began joining the community group, which now has over 750 members, more than 100 discussion topics, and over 50 announcements about software updates. In early 2023, most discussion topics were questions about using the software, its capabilities, and a few bug reports. We fixed the reported bugs and provided educational videos (see Table 13) to help users learn about the software and how to use it [85]. Then, we guided them to the PWCT2 samples and Ring language documentation to learn more about the software. Many of the recent topics in 2024 are questions about future directions and requests to support other textual programming languages like Lua, Python, and C#.
Based on statistics from the Steam platform regarding PWCT2 web page visits from March 2023 to December 2024, the platform displayed the project title, logo, and short description over 1.73 million times to users through various lists. The software web page received over 159 K visits (a 9.2% clickthrough rate), including over 72 K visits from the United States, over 33 K visits from the Russian Federation, and over 11 K visits from Saudi Arabia. Over 20,000 users own the software and have added it to their Steam library, enabling them to download and use it at any time. In Table 14, we present the minimum usage time and the percentage of users as reported by the Steam platform. Steam reported that 1772 users have downloaded and launched the software through Steam, with an average usage time of 9 h and 40 min. This means the software has been used for over 17,000 h as shown in Table 15.
In Figure 27, we present a horizontal bar chart that shows the download statistics of the PWCT2 software across different regions, listing only the top regions, such as North America and Western Europe.
The regions and their corresponding percentages are as follows: North America at 36.20%, Western Europe at 25.70%, Latin America at 6.20%, Central Asia at 6.10%, Asia at 5.90%, and Eastern Europe at 5.20%. The chart highlights the significant differences in the distribution of downloads across these regions, with North America having the highest percentage and Eastern Europe having the lowest. In Figure 28, we present the downloads across the top countries, showing that the United States has the highest number of downloads (31%), followed by Germany (10%) and Canada (5%).
We conducted an analysis for the user reviews for the PWCT2 software on the Steam platform, while noticing important details such as review type, language used to write the review, and usage time in hours. The reviews are written in various languages, indicating a diverse user base. Out of the thirty-one reviews, twenty-eight users recommended the software, while three users did not. The languages used in the reviews include Arabic, Chinese, English, Italian, Polish, Portuguese, Russian, Thai, and Turkish. Usage times vary significantly, from as little as 0.1 h to an extensive 560.1 h. Notably, a user who used the software for 560.1 h recommended it, showing a high level of engagement. Other notable usage times (in their respective review languages) include 93.4 h (Thai), 61.4 h (English), and 56 h (Portuguese), all with positive recommendations.
Figure 29 illustrates the proportion of positive and negative reviews for the PWCT2 software on the Steam platform. The user reviews provide a mix of positive and critical feedback. Users appreciate the software’s educational value, especially for beginners. The visual and organized approach to programming is praised, with some comparisons to Scratch. Users find it helpful for those with little coding knowledge and believe it has great potential for learning programming.
With respect to negative feedback, we noticed that it was based on various reasons, including encountering bugs, requiring more educational resources, and seeking additional features to enhance usability. During 2023 and 2024, we worked on resolving all reported bugs, introduced more educational resources (videos and documentation), and added requested features such as Drag-and-Drop support in the Goal Designer, an expression builder in the interaction pages, as well as preventing composition errors in the Steps Tree. However, we believe there is room for further improvement in the educational resources and the features provided.
The software’s interface is described as smooth, with many features to learn. Some users highlight the convenience of having the entire programming interface visible and the ability to keep necessary interaction pages open. Some users also express satisfaction with features like Ring2PWCT and the Time Machine, which enhance their programming experience. There are positive remarks about the potential for serious projects. Many users express satisfaction with the software’s development and updates. On the other hand, a few users feel the software is not beginner-friendly and recommend it only for those with prior programming knowledge. Continued development and support are encouraged, with some users acknowledging our responsiveness in fixing issues. Overall, the reviews highlight both the strengths and areas for improvement in PWCT2, reflecting diverse user experiences and perspectives.
5. Discussion
The diverse use cases of PWCT2 demonstrate its adaptability and utility in various programming scenarios. The primary use case for PWCT2 is as an alternative to the Ring Code Editor, which allows users to create new projects based on Ring, as well as visualize and execute Ring programs. This flexibility is further enhanced by the Time Machine feature, which enables users to read programs step by step and run them from a previous point in time, facilitating the continued development and maintenance of numerous Ring samples and applications. Additionally, PWCT2 supports the development of GUI applications through its Form Designer, which has been utilized to create applications for predicting citation counts in the Otology field and for finding files distributed with Ring Notepad. These applications showcase PWCT2’s capability to handle different tasks, such as integrating machine learning models developed using Microsoft Azure Machine Learning and providing user-friendly interfaces. Moreover, PWCT2’s ability to convert Ring textual code into visual code and vice versa using the Ring2PWCT tool underscores its potential as a flexible tool in both educational and professional settings. The practical use cases of PWCT2 highlight its contributions to simplifying programming and enhancing the overall development process based on the Ring programming language.
The results presented in Table 8 and Table 9 highlight the excellent compilation performance achieved during the development of PWCT2 using various versions of the Ring language. Furthermore, the number of byte-code instructions decreased in Ring 1.22, indicating more efficient byte-code generation. However, despite these improvements, the size of the generated Ring object file remains relatively large, even though there was a reduction from 22,825 KB in Ring 1.19 to 18,952 KB in Ring 1.22. Addressing the large object file size could reduce the storage and memory requirements of the PWCT2 project. Table 10 and Table 11 present an insightful comparison of PWCT2’s performance and its improvements over PWCT1 [23]. PWCT2 demonstrates significant enhancements in file storage efficiency and code generation time. The results show that PWCT2 has much smaller file sizes, and a notably faster code generation compared to PWCT1, which is crucial during multiple programs runs and updates.
User feedback has played a crucial role in the development and refinement of PWCT2. Since its distribution as a visual programming tool and a replacement for the Ring Code Editor, the community group has grown significantly, now boasting over 750 members. Notably, over 20,000 users have added the software to their Steam libraries, enabling them to download and use it anytime. Steam reported that 1772 users have launched the software, with an average usage time of 9 h and 40 min, cumulatively amounting to over 17,000 h of usage (Table 15). Regional and country-specific download data highlight that North America and the United States lead in downloads (Figure 27 and Figure 28). User reviews on Steam (Figure 29) also present a mix of positive and critical feedback, with notable appreciation for the educational value, smooth interface, and unique features like Ring2PWCT and the Time Machine.
Since PWCT2 currently supports the Ring programming language through RingPWCT visual components, these visual components follow the Ring language approach for representing different data structures, where Ring lists are used instead of arrays, linked lists, trees, hash tables, etc. However, by using classes and operator overloading, we can create custom types. The Ring Standard Library comes with specific classes for lists, trees, hash tables, etc., and the RingPWCT includes visual components that enable the use of these classes. With respect to scalability and creating large projects, the PWCT2 approach is based on organizing large projects into folders, subfolders, and different visual source files, where a visual source file can load other files and use the functionality provided by them, such as functions and classes. However, more improvements are required in this area to provide visualizations that highlight information from different visual source files.
The development and evaluation of PWCT2, the proposed research prototype and successor to PWCT1, bring several noteworthy limitations to light. First and foremost, PWCT2 supports only the Ring programming language, whereas PWCT1 provided visual components for various textual programming languages, including Harbour, C, Supernova, Python, and C# [17]. This limitation restricts the versatility of PWCT2 and may reduce its appeal to users who require support for multiple programming languages. Secondly, PWCT2 is not compatible with PWCT1 in terms of visual component design or visual source file formats. This incompatibility necessitates the development of tools to convert projects from PWCT1 to PWCT2, which could pose challenges for users looking to transition their existing projects. Additionally, PWCT2 is currently distributed as a desktop tool rather than a web-based application. The lack of a web-based version limits accessibility and convenience, highlighting a potential area for future development to enhance user experience and broaden the tool’s reach. Since PWCT2 is based on the Qt framework, which supports WebAssembly, and the Ring language also supports the WebAssembly platform, we plan to develop PWCT2 for WebAssembly in the future. At this stage, we have an online version of the Form Designer, and other components will be ported as well. While PWCT2 includes the Ring2PWCT feature, which allows it to accept Ring code generated by large language models, the process currently requires a copy-and-paste operation (e.g., from Copilot to PWCT2) [77]. A fully integrated solution, where writing a natural language prompt directly generates a visual representation without needing manual transfer, would be more efficient and user-friendly. This enhancement could significantly streamline the workflow and improve usability. Moreover, despite providing 39 instructional videos to explain PWCT2 features, using PWCT2 still demands a general understanding of programming and specific knowledge of the Ring language [85]. To achieve broader adoption, it may be necessary to expand educational resources, including tutorials and documentation, to support users with varying levels of expertise.
In summary, while PWCT2 advances the capabilities of its predecessor and offers a robust platform for developing Ring-based applications, addressing the limitations identified could enhance its functionality, user experience, and appeal to a broader audience. Future work should focus on expanding language support, ensuring compatibility with PWCT1, developing a web-based version, improving integration with natural language processing tools, and enhancing educational resources to support a diverse user base.
6. Conclusions and Future Work
In this research paper, we introduced PWCT2, a visual programming language developed and maintained for many years using the Ring programming language. Visual programming languages are helpful in making programming easier and faster to learn. This study introduces some useful improvements. We have developed a new version of the PWCT visual programming language that includes enhanced features, works on different systems, performs code generation more efficiently than before, and reduces storage requirements.
We also created the first visual programming language that generates code in the Ring programming language. This helps combine the ease of visual programming with the flexibility of Ring. Additionally, we tested how well the Ring programming language Compiler/VM works for developing an advanced project like PWCT2. We also designed a tool to convert textual Ring code into visual code in PWCT2, making it easier to use. These improvements show that there is potential for making visual programming languages more accessible and effective for Ring developers. Our work provides a foundation for further development in this area.
In the future, we aim to enhance PWCT2 by supporting additional textual programming languages such as C, Java, C# and Python. We also plan to improve the environment by offering translations in various human languages, to make it more accessible to a global audience. Moreover, we intend to add more components that provide better support for Ring libraries, further enriching the functionality and usability of PWCT2. These enhancements will continue to build on the progress made and open new possibilities for users and developers.
Conceptualization, M.S.F. and Y.A.A.; methodology, M.S.F. and Y.A.A.; software, M.S.F.; validation, M.S.F. and Y.A.A.; formal analysis, M.S.F. and Y.A.A.; investigation, M.S.F. and Y.A.A.; resources, M.S.F. and Y.A.A.; data curation, M.S.F. and Y.A.A.; writing—original draft preparation, M.S.F.; writing—review and editing, M.S.F. and Y.A.A.; visualization, M.S.F.; supervision, Y.A.A.; project administration, Y.A.A.; funding acquisition, Y.A.A. All authors have read and agreed to the published version of the manuscript.
Not applicable.
Not applicable.
The data used to support the findings of this study are available from the corresponding author upon request.
The authors thank Eng. Ahmed Samir Fayed for his help in preparing the electronic board of the Raspberry Pi Pico sample in
The authors declare no conflicts of interest.
The following abbreviations are used in this manuscript:
| CGT | Code Generation Time |
| DAD | Drag and Drop |
| GCR | Graphical Code Replacement |
| GPE | Graphical Program Editor |
| GUI | Graphical User Interface |
| IDE | Integrated Development Environment |
| KLOC | Thousands of lines of code |
| LabVIEW | Laboratory Virtual Instrument Engineering Workbench |
| LLM | Large Language Model |
| LOC | Lines of Code |
| LT | Loading Time |
| ML | Machine Learning |
| MVC | Model View Controller |
| OOP | Object-Oriented Programming |
| PWCT | Programming Without Coding Technology |
| VFP | Visual FoxPro |
| VI | Visual Implementation |
| VM | Virtual Machine |
| VPL | Visual Programming Language |
Footnotes
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Enlarge this image.Figure 1. Some of the visual programming languages that have been developed starting from 1966.
Enlarge this image.Figure 2. Using PWCT to develop the compiler and virtual machine for the Ring language.
Enlarge this image.Figure 3. The key features of the proposed visual programming language and environment.
Enlarge this image.Figure 6. Inserting steps in the Steps Tree and using the Find and Replace window.
Enlarge this image.Figure 7. Using a component that generates steps that belong to other components.
Enlarge this image.Figure 22. Generated bytecode instructions for PWCT2 from Ring 1.17 to Ring 1.22.
Enlarge this image.Figure 24. The relationship between the number of steps and the required storage.
Some categories of visual programming languages and examples.
| Refs. | Category | Examples |
|---|---|---|
| [ | Block-based | Scratch, Snap!, etc. |
| [ | Diagrammatic | Tersus, RAPTOR, etc. |
| [ | Iconic | Kodu, Limnor, etc. |
| [ | Form-based and spreadsheet-based | Forms/3, FAR, etc. |
| [ | Domain-specific | Blueprints, Pure Data, etc. |
| [ | General-purpose | PWCT, Envision, etc. |
The main features of the proposed visual programming language.
| Criteria | Scratch | Forms/3 | Envision | Lava | PWCT | Proposed |
|---|---|---|---|---|---|---|
| Open Source | √ | X | √ | √ | √ | √ |
| Portable | √ | X | √ | √ | X | √ |
| Rich Colors | √ | X | √ | X | X | √ |
| Time Dimension | X | √ | X | X | √ | √ |
| Auto-Run | √ | √ | X | X | X | √ |
| Rich-Comments | X | X | √ | X | X | √ |
| Generate Ring Code | X | X | X | X | X | √ |
| Interactive Visualization | X | X | √ | X | X | √ |
| Implementation using Ring | X | X | X | X | X | √ |
| Import Ring Code | X | X | X | X | X | √ |
| Self-hosting | X | X | * | X | X | √ |
| Form Designer | X | √ | X | √ | √ | √ |
| Steps Tree/Blocks | √ | X | X | √ | √ | √ |
| Steps Tree/Blocks (DAD) | √ | X | X | X | X | √ |
| Play programs as movie | X | X | X | X | √ | √ |
| Supports OOP | X | X | √ | √ | √ | √ |
| Designed for Children | √ | X | X | X | X | X |
| Just for Research | X | √ | √ | √ | X | X |
The RingPWCT visual programming language components.
| ID | Domain | Components Count | Example |
|---|---|---|---|
| 1 | General | 6 | Quick Start |
| 2 | Console | 4 | Print Text |
| 3 | Control Structures | 13 | For-In Loop |
| 4 | Variables and Operators | 17 | Assignment |
| 5 | Functions | 3 | Define Function |
| 6 | Program Structure | 2 | Load Source File |
| 7 | Lists | 15 | New Empty List |
| 8 | Strings | 16 | Get String Length |
| 9 | Date and Time | 7 | Add Days |
| 10 | Check Data Type | 3 | Check Character |
| 11 | Math | 1 | Math Functions |
| 12 | Files | 29 | Read File to String |
| 13 | System | 12 | Get System Variable |
| 14 | Dynamic Code | 3 | Eval |
| 15 | Database | 34 | ODBC Connect |
| 16 | Security and Internet Functions | 11 | Download |
| 17 | Object-Oriented Programming | 10 | Define Class |
| 18 | Functional Programming | 3 | Anonymous Function |
| 19 | Reflection | 29 | Globals Info |
| 20 | Standard Library | 71 | Stack Class |
| 21 | Web Library | 12 | WL WebPage Class |
| 22 | LibCurl Library | 5 | LibCurl Easy Init |
| 23 | GUI | 88 | Window Class |
Different types of Steps inside the Steps Tree.
| ID | Step Type | Description |
|---|---|---|
| 1 | Start Point | The program root (one for each visual source file) |
| 2 | Comment | Just a comment and does nothing during runtime |
| 3 | First | The first step generated by the component |
| 4 | Allows Interaction | The step could include sub steps |
| 5 | Leaf | The step cannot include sub steps |
Using Copilot and PWCT2.
| Step | Description | Image |
|---|---|---|
| 1 | Use Copilot AI to generate textual source code in the Ring programming language, then copy the generated code to the operating system clipboard. The task is to write a method in Ring code to be added to a class called Point, which has three attributes: x, y, and z. The method should ask the user for the values of these attributes using the getNumber() function and print a message asking the user to enter the value before using getNumber(). The provided solution includes a method named ask_values that prompts the user to enter values for x, y, and z. This method assigns these values to the respective attributes after using the getNumber() function to obtain input from the user. | [Image omitted. Please see PDF.] |
| 2 | In this step, we switch to PWCT2, select the parent step in the Steps Tree Editor, and finally paste the generated source code. The parent step is called “Methods”, which exists in the Point class. Once we paste the textual source code, PWCT will display the pasted code in a popup rectangle to indicate that this is a textual-to-visual code conversion operation (not a search operation by the visual component name). Pressing ENTER will start the conversion process. | [Image omitted. Please see PDF.] |
| 3 | After the textual-to-visual code conversion process using Ring2PWCT, we will see the generated steps in the Steps Tree. We can continue development using the visual programming features provided by PWCT2, such as the Steps Tree Editor and Time Machine. | [Image omitted. Please see PDF.] |
Using Ring2PWCT to convert the PrintComponentView class.
| Attribute | Value |
|---|---|
| Class Name | PrintComponentView |
| Parent Class | ComponentViewParent |
| Textual Source | [Image omitted. Please see PDF.] |
| Visual Source | [Image omitted. Please see PDF.] |
PWCT2 modules.
| ID | Module | Files | LOC | Comment |
|---|---|---|---|---|
| 1 | Environment | 5 | 2649 | 300 |
| 2 | General Functions | 9 | 524 | 122 |
| 3 | Translation | 3 | 584 | 20 |
| 4 | Goal Designer | 27 | 4908 | 1473 |
| 5 | Components Browser | 5 | 8876 | 70 |
| 6 | VPL Components | 1185 | 57,612 | 7167 |
| 7 | Component Parent Classes | 3 | 739 | 283 |
| 8 | Form Designer | 52 | 9487 | 312 |
| 9 | File System (Visual Source Files) | 6 | 368 | 415 |
| 10 | Tools | 59 | 6484 | 546 |
PWCT2 project size including dependencies.
| Attribute | Value |
|---|---|
| Source code files | 1354 |
| Lines of Code | 92 KLOC |
| Dependencies | 27 KLOC |
| Total Lines of Code | 119 KLOC |
Using Ring to build the PWCT2 project.
| Attribute | Ring 1.17 | Ring 1.19 | Ring 1.22 |
|---|---|---|---|
| Compile-time (ms) | 1480 | 1152 | 871 |
| Byte-code Instructions | 900,113 | 899,984 | 724,382 |
| Ring Object File Size (KB) | 22,184 | 22,825 | 18,952 |
| Object File Compressed (KB) | 2463 | 2483 | 2322 |
Measuring performance of PWCT2.
| ID | File | Storage (KB) | Components | Steps | LOC | LT (ms) | CGT (ms) |
|---|---|---|---|---|---|---|---|
| 1 | StopWatch | 41 | 40 | 74 | 54 | 73 | 3 |
| 2 | Snake | 138 | 149 | 234 | 185 | 199 | 9 |
| 3 | Matching | 218 | 215 | 330 | 275 | 287 | 13 |
| 4 | Sokoban | 217 | 235 | 330 | 269 | 269 | 13 |
| 5 | Escape | 250 | 277 | 401 | 329 | 330 | 14 |
| 6 | Tessera | 268 | 269 | 418 | 337 | 370 | 17 |
| 7 | FlappyBird3000 | 260 | 263 | 429 | 341 | 358 | 17 |
| 8 | Pairs | 283 | 287 | 432 | 362 | 374 | 17 |
| 9 | Cards | 298 | 305 | 457 | 399 | 363 | 15 |
| 10 | SquaresPuzzle | 299 | 327 | 513 | 378 | 429 | 20 |
| 11 | StarsFighter | 321 | 329 | 530 | 423 | 449 | 21 |
| 12 | KnightTour | 347 | 386 | 549 | 465 | 448 | 21 |
| 13 | Tetris | 351 | 402 | 586 | 483 | 459 | 20 |
| 14 | Game2048 | 371 | 356 | 588 | 461 | 499 | 22 |
| 15 | Othello | 427 | 422 | 653 | 536 | 562 | 25 |
| 16 | DiscreteFourierTransform | 787 | 538 | 677 | 603 | 784 | 22 |
| 17 | MagicBalls | 438 | 510 | 700 | 602 | 567 | 24 |
| 18 | Minesweeper | 449 | 509 | 701 | 611 | 559 | 24 |
| 19 | SuperMan | 465 | 480 | 757 | 607 | 622 | 30 |
| 20 | Laser | 707 | 825 | 1139 | 955 | 918 | 39 |
| 21 | GameOfLife | 773 | 870 | 1253 | 1066 | 1068 | 43 |
| 22 | Checkers | 845 | 968 | 1307 | 1128 | 1077 | 43 |
| 23 | GoGame | 946 | 1089 | 1453 | 1271 | 1166 | 47 |
| 24 | GetQuotesHistory | 1021 | 1269 | 1555 | 1407 | 1228 | 51 |
| 25 | Chess | 1012 | 1166 | 1560 | 1340 | 1270 | 52 |
A table of some visual source files containing steps equal to or greater than 1000 steps.
| Generation | VPL | File | Storage (KB) | Steps | LT (ms) | CGT (ms) |
|---|---|---|---|---|---|---|
| PWCT2 | RingPWCT | GameOfLife | 773 | 1253 | 1068 | 43 |
| PWCT2 | RingPWCT | Checkers | 845 | 1307 | 1077 | 43 |
| PWCT2 | RingPWCT | GoGame | 946 | 1453 | 1166 | 47 |
| PWCT2 | RingPWCT | Chess | 1012 | 1560 | 1270 | 52 |
| PWCT1 | CPWCT | Vmfuncs | 7966 | 1000 | 549 | 1748 |
| PWCT1 | CPWCT | Refmeta_ext | 8243 | 1075 | 593 | 1993 |
| PWCT1 | CPWCT | File_ext | 9799 | 1235 | 747 | 2651 |
| PWCT1 | CPWCT | Vm_oop | 11397 | 1497 | 862 | 3862 |
Statistical Analysis of RingPWCT and CPWCT samples.
| Attribute | PWCT1 | PWCT2 |
|---|---|---|
| Visual Programming Language | CPWCT | RingPWCT |
| Visual Source Files Count (Sample Size) | 43 | 25 |
| Pearson Correlation (Storage vs. Steps) | 0.8693 | 0.9662 |
| Pearson Correlation (CGT vs. Steps) | 0.9105 | 0.9947 |
| Spearman Correlation (Storage vs. Steps) | 0.8198 | 0.9867 |
| Spearman Correlation (CGT vs. Steps) | 0.9914 | 0.9855 |
| Average Storage per Step (KB/step) | 13.6751 | 0.6543 |
| Average CGT per Step (ms/step) | 1.2956 | 0.0353 |
| RMSE for Storage | 23.4063 | 0.1082 |
| RMSE for CGT | 1.0539 | 0.0032 |
Statistics about educational videos introducing PWCT2.
| Attribute | Value |
|---|---|
| Total Videos Count | 39 |
| Average Duration (M:S) | 8:47 |
| Total Duration (H:M:S) | 5:42:27 |
Usage time as reported by the Steam platform.
| Minimum Usage Time | Percentage of Users |
|---|---|
| 30 min | 27% |
| 1 h 0 min | 19% |
| 2 h 0 min | 13% |
| 5 h 0 min | 8% |
| 10 h 0 min | 5% |
Statistics about the PWCT2 software from 1 March 2023 to 21 December 2024.
| Attribute | Value |
|---|---|
| Impressions | 1.72 M |
| Web page visits | 159 K |
| Software owners | 20,623 |
| Users launched the software | 1772 |
| Average usage time | 9 h and 40 min |
| Total usage time | Over 17,000 h |
References
1. Noone, M.; Mooney, A. Visual and textual programming languages: A systematic review of the literature. J. Comput. Educ.; 2018; 5, pp. 149-174. [DOI: https://dx.doi.org/10.1007/s40692-018-0101-5]
2. Mitchell, J.C. Concepts in Programming Languages; Cambridge University Press: Cambridge, UK, 2003.
3. Penev, A.; Vassilev, M. Visual differential debugging in the domain-specific visual programming languages. Proceedings of the 2020 International Conference Automatics and Informatics (ICAI); Varna, Bulgaria, 1–3 October 2020; pp. 1-6.
4. Burnett, M.M.; McIntyre, D.W. Visual programming. Computer; 1995; 28, pp. 14-16.
5. Sutherland, W.R. The On-Line Graphical Specification of Computer Procedures. Ph.D. Thesis; Massachusetts Institute of Technology: Cambridge, MA, USA, 1966.
6. Smith, D.C. Pygmalion: A Creative Programming Environment; Stanford University: Stanford, CA, USA, 1975.
7. Cox, P.T.; Giles, F.R.; Pietrzykowski, T. Prograph: A step towards liberating programming from textual conditioning. Proceedings of the 1989 IEEE Workshop on Visual Languages; Rome, Italy, 4–6 October 1989; pp. 150-151.
8. Singh, D.; Singh, M.; Hakimjon, Z.; Singh, D.; Singh, M.; Hakimjon, Z. Requirements of MATLAB/Simulink for signals. Signal Processing Applications Using Multidimensional Polynomial Splines; Springer: Dordrecht, The Netherlands, 2019; pp. 47-54.
9. Kodosky, J. LabVIEW. Proc. ACM Program. Lang.; 2020; 4, pp. 1-54. [DOI: https://dx.doi.org/10.1145/3386328]
10. Kalemkuş, J.; Kalemkuş, F. The Effects of Designing Scientific Experiments with Visual Programming Language on Learning Outcomes. Sci. Educ.; 2024; pp. 1-22. [DOI: https://dx.doi.org/10.1007/s11191-024-00546-8]
11. Asenov, D.; Muller, P. Envision: A fast and flexible visual code editor with fluid interactions (overview). Proceedings of the 2014 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC); Melbourne, Australia, 28 July–1 August 2014; pp. 9-12.
12. Hagino, T. Practical Node-RED Programming: Learn Powerful Visual Programming Techniques and Best Practices for the Web and IoT; Packt Publishing Ltd.: Birmingham, UK, 2021.
13. Torres, D.; Dias, J.P.; Restivo, A.; Ferreira, H.S. Real-time feedback in node-red for iot development: An empirical study. Proceedings of the 2020 IEEE/ACM 24th International Symposium on Distributed Simulation and Real Time Applications (DS-RT); Prague, Czech Republic, 14–16 September 2020; pp. 1-8.
14. Chu, E.; Zaman, L. Exploring alternatives with unreal engine’s blueprints visual scripting system. Entertain. Comput.; 2021; 36, 100388. [DOI: https://dx.doi.org/10.1016/j.entcom.2020.100388]
15. Turchi, T. FlowPilot: A Generative AI-Driven Visual Language for Computational Thinking Education. Proceedings of the 2024 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC); Liverpool, UK, 2–6 September 2024; pp. 353-355.
16. Fayed, M.S.; Al-Qurishi, M.; Alamri, A.; Al-Daraiseh, A.A. PWCT: Visual language for IoT and cloud computing applications and systems. Proceedings of the Second International Conference on Internet of things, Data and Cloud Computing; Xuzhou, China, 22–24 September 2023; pp. 1-5.
17. Fayed, M.S.; Al-Qurishi, M.; Alamri, A.; Hossain, M.A.; Al-Daraiseh, A.A. PWCT: A novel general-purpose visual programming language in support of pervasive application development. CCF Trans. Pervasive Comput. Interact.; 2020; 2, pp. 164-177. [DOI: https://dx.doi.org/10.1007/s42486-020-00038-y]
18. Green, T.R.G.; Petre, M. Usability analysis of visual programming environments: A ‘cognitive dimensions’ framework. J. Vis. Lang. Comput.; 1996; 7, pp. 131-174. [DOI: https://dx.doi.org/10.1006/jvlc.1996.0009]
19. Green, T.; Blackwell, A. Cognitive dimensions of information artefacts: A tutorial. BCS HCI Conference; Springer: Sheffield, UK, 1998; Volume 98, pp. 1-75.
20. Green, T.R.G.; Blandford, A.E.; Church, L.; Roast, C.R.; Clarke, S. Cognitive dimensions: Achievements, new directions, and open questions. J. Vis. Lang. Comput.; 2006; 17, pp. 328-365. [DOI: https://dx.doi.org/10.1016/j.jvlc.2006.04.004]
21. Fayed, M.S. General-purpose visual language and information system with case-studies in developing business applications. arXiv; 2017; arXiv: 1712.10281
22. Granor, T.E.; Hennig, D.; Roche, T.; Martin, D. Hacker’s Guide to Visual FoxPro 7.0; Hentzenwerke: Milwaukee, WI, USA, 2002.
23. Fayed, M.S.; Alohali, Y.A. Ring: A Lightweight and Versatile Cross-Platform Dynamic Programming Language Developed Using Visual Programming. Electronics; 2024; 13, 4627. [DOI: https://dx.doi.org/10.3390/electronics13234627]
24. Żyła, K.; Chwaleba, K.; Choma, D. Evaluating Usability and Accessibility of Visual Programming Tools for Novice Programmers—The Case of App Inventor, Scratch, and StarLogo. Appl. Sci.; 2024; 14, 9887. [DOI: https://dx.doi.org/10.3390/app14219887]
25. Marji, M. Learn to Program with Scratch: A Visual Introduction to Programming with Games, Art, Science, and Math; No Starch Press: San Francisco, CA, USA, 2014.
26. Maloney, J.; Resnick, M.; Rusk, N.; Silverman, B.; Eastmond, E. The scratch programming language and environment. ACM Trans. Comput. Educ.; 2010; 10, pp. 1-15. [DOI: https://dx.doi.org/10.1145/1868358.1868363]
27. Asenov, D. Envision: Reinventing the Integrated Development Environment. Ph.D. Thesis; ETH Zurich: Zürich, Switzerland, 2017.
28. Lüthi, P. Self-Hosting the Envision Visual Programming Environment. Master’s Thesis; ETH Zurich: Zürich, Switzerland, 2015.
29. McNeish, K. NET for Visual FoxPro Developers; Hentzenwerke: Milwaukee, WI, USA, 2002.
30. Ayouni, M. Beginning Ring Programming; Apress: New York, NY, USA, 2020; Volume 978, No. 1
31. Green, T.R.G. Noddy’s Guide to… Visual Programming. Interfaces, The British Computer Society; Human-Computer Interaction Group: Geneva, Switzerland, 1995.
32. Burnett, M.M.; Baker, M.J. A classification system for visual programming languages. J. Vis. Lang. Comput.; 1994; 5, pp. 287-300. [DOI: https://dx.doi.org/10.1006/jvlc.1994.1015]
33. Kuhail, M.A.; Farooq, S.; Hammad, R.; Bahja, M. Characterizing visual programming approaches for end-user developers: A systematic review. IEEE Access; 2021; 9, pp. 14181-14202. [DOI: https://dx.doi.org/10.1109/ACCESS.2021.3051043]
34. Meerbaum-Salant, O.; Armoni, M.; Ben-Ari, M. Habits of programming in scratch. Proceedings of the 16th Annual Joint Conference on Innovation and Technology in Computer Science Education; New York, NY, USA, 27–29 June 2011; pp. 168-172.
35. Feng, A.; Gardner, M.; Feng, W. Parallel programming with pictures is a Snap!. J. Parallel Distrib. Comput.; 2017; 105, pp. 150-162. [DOI: https://dx.doi.org/10.1016/j.jpdc.2017.01.018]
36. Kahn, K.; Megasari, R.; Piantari, E.; Junaeti, E. AI programming by children using snap! Block programming in a developing country. Thirteenth European Conference on Technology Enhanced Learning; Springe: Berlin/Heidelberg, Germany, 2018; Volume 11082.
37. Brandes, O. Tersus visual programming platform. Proceedings of the 2011 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC); Pittsburgh, PA, USA, 18–22 September 2011; pp. 245-246.
38. Dieng, N. A Proposed Unified Visual Programming Language; Oklahoma State University: Stillwater, OK, USA, 2010.
39. Carlisle, M.C.; Wilson, T.A.; Humphries, J.W.; Hadfield, S.M. RAPTOR: A visual programming environment for teaching algorithmic problem solving. Acm Sigcse Bull.; 2005; 37, pp. 176-180. [DOI: https://dx.doi.org/10.1145/1047124.1047411]
40. Carlisle, M.C. Raptor: A visual programming environment for teaching object-oriented programming. J. Comput. Sci. Coll.; 2009; 24, pp. 275-281.
41. Hirakawa, M.; Tanaka, M.; Ichikawa, T. An iconic programming system, HI-VISUAL. IEEE Trans. Softw. Eng.; 1990; 16, pp. 1178-1184. [DOI: https://dx.doi.org/10.1109/32.60297]
42. McIntyre, D.W.; Glinert, E.P. Visual tools for generating iconic programming environments. Proceedings of the IEEE Workshop on Visual Languages; Seattle, DC, USA, 15–18 September 1992; pp. 162-168.
43. MacLaurin, M.B. The design of Kodu: A tiny visual programming language for children on the Xbox 360. Proceedings of the 38th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages; Austin, TX, USA, 26–28 January 2011; pp. 241-246.
44. MacLaurin, M. Kodu: End-user programming and design for games. Proceedings of the 4th International Conference on Foundations of Digital Games; Orlando, FL, USA, 26–30 April 2009; pp. xviii-xix.
45. Burnett, M.; Atwood, J.; Djang, R.W.; Reichwein, J.; Gottfried, H.; Yang, S. Forms/3: A first-order visual language to explore the boundaries of the spreadsheet paradigm. J. Funct. Program.; 2001; 11, pp. 155-206. [DOI: https://dx.doi.org/10.1017/S0956796800003828]
46. van Zee, P.J. Exception Handling in the Visual Programming Language Forms/3. Master’s Thesis; 1995; Available online: https://ir.library.oregonstate.edu/concern/graduate_projects/mw22vd90v (accessed on 24 December 2024).
47. Burnett, M.; Chekka, S.K.; Pandey, R. FAR: An end-user language to support cottage e-services. Proceedings of the IEEE Symposia on Human-Centric Computing Languages and Environments (Cat. No. 01TH8587); Auckland, New Zealand, 28–31 October 2001; pp. 195-202.
48. Romero, M.; Sewell, B. Blueprints Visual Scripting for Unreal Engine 5: Unleash the True Power of Blueprints to Create Impressive Games and Applications in UE5; Packt Publishing Ltd.: Birmingham, UK, 2022.
49. Islam, A.; Eng, K.; Hindle, A. Opening the Valve on Pure-Data: Usage Patterns and Programming Practices of a Data-Flow Based Visual Programming Language. Proceedings of the 2024 IEEE/ACM 21st International Conference on Mining Software Repositories (MSR); Lisbon, Portugal, 15–16 April 2024; pp. 492-497.
50. PWCT Team. PWCT Software. Available online: https://doublesvsoop.sourceforge.net (accessed on 24 December 2024).
51. Asenov, D.; Müller, P. Customizing the visualization and interaction for embedded domain-specific languages in a structured editor. Proceedings of the 2013 IEEE Symposium on Visual Languages and Human Centric Computing; San Jose, CA, USA, 15–19 September 2013; pp. 127-130.
52. Sáez-López, J.-M.; Román-González, M.; Vázquez-Cano, E. Visual programming languages integrated across the curriculum in elementary school: A two year case study using “Scratch” in five schools. Comput. Educ.; 2016; 97, pp. 129-141. [DOI: https://dx.doi.org/10.1016/j.compedu.2016.03.003]
53. Burnett, M.; Cao, N.; Arredondo-Castro, M.; Atwood, J. End-user programming of time as an ‘ordinary’dimension in grid-oriented visual programming languages. J. Vis. Lang. Comput.; 2002; 13, pp. 421-447. [DOI: https://dx.doi.org/10.1006/jvlc.2002.0241]
54. Asenov, D.; Hilliges, O.; Müller, P. The effect of richer visualizations on code comprehension. Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems; San Jose, CA, USA, 7–12 May 2016; pp. 5040-5045.
55. Günther, K.D.; Günther, I. Lava–An Object-Oriented RAD Language Designed for Ease of Learning, Use, and Program Comprehension; Institut fur Informatik und Praktische Mathematik: Hannover, Germany, 2001.
56. Chin, J.M.; Chin, M.H.; Van Landuyt, C. A String Search Marketing Application Using Visual Programming. e-J. Bus. Educ. Scholarsh. Teach.; 2013; 7, pp. 46-58.
57. Chok, S.S.; Marriott, K. Automatic generation of intelligent diagram editors. ACM Trans. Comput.-Hum. Interact.; 2003; 10, pp. 244-276. [DOI: https://dx.doi.org/10.1145/937549.937553]
58. Costagliola, G.; Deufemia, V.; Polese, G.; Risi, M. Building syntax-aware editors for visual languages. J. Vis. Lang. Comput.; 2005; 16, pp. 508-540. [DOI: https://dx.doi.org/10.1016/j.jvlc.2005.06.001]
59. Pasternak, E.; Fenichel, R.; Marshall, A.N. Tips for creating a block language with blockly. Proceedings of the 2017 IEEE Blocks and Beyond Workshop (B&B); Raleigh, NC, USA, 9–10 October 2017; pp. 21-24.
60. Trower, J.; Gray, J. Blockly language creation and applications: Visual programming for media computation and bluetooth robotics control. Proceedings of the 46th ACM Technical Symposium on Computer Science Education; Kansas City, MO, USA, 4–7 March 2015; 5.
61. Hurlburt, G.F. Low-Code, No-Code, What’s Under the Hood?. IT Prof.; 2021; 23, pp. 4-7. [DOI: https://dx.doi.org/10.1109/MITP.2021.3123415]
62. Rokis, K.; Kirikova, M. Challenges of low-code/no-code software development: A literature review. International Conference on Business Informatics Research; Springer International Publishing: Cham, Switzerland, 2022; pp. 3-17.
63. Rabuske, T. Polymath: A platform for rapid application development of modular EDA tools. Proceedings of the 2020 IEEE International Symposium on Circuits and Systems (ISCAS); Virtual, 10–21 October 2020; pp. 1-5.
64. Heisen, B.; Boukhelef, D.; Esenov, S.; Hauf, S.; Kozlova, I.; Maia, L.; Parenti, A.; Weger, K.; Wrona, K.; Youngman, C. et al. Karabo: An integrated software framework combining control, data management, and scientific computing tasks. Proceedings of the 14th International Conference on Accelerator & Large Experimental Physics Control Systems, ICALEPCS2013; San Francisco, CA, USA, 6–11 October 2013.
65. PWCT Team. PWCT Features—Framework and Extension. Available online: https://doublesvsoop.sourceforge.net/pwcthelp/features/frameworkandextension.htm (accessed on 24 December 2024).
66. Lee, Y.-J. Scratch: Multimedia programming environment for young gifted learners. Gift. Child Today; 2011; 34, pp. 26-31. [DOI: https://dx.doi.org/10.1177/107621751103400208]
67. Ritchie, P. Practical Microsoft Visual Studio 2015; Apress: Berkeley, CA, USA, 2016.
68. Boudreau, T.; Glick, J.; Greene, S.; Spurlin, V.; Woehr, J.J. NetBeans: The Definitive Guide: Developing, Debugging, and Deploying Java Code; O’Reilly Media, Inc.: Sebastopol, CA, USA, 2002.
69. Steamplatform. GoldMagic800 Game. 2018; Available online: https://store.steampowered.com/app/939200/Gold_Magic_800/ (accessed on 24 December 2024).
70. Smith, S.; Smith, S. How to Connect Pico to IoT. RP2040 Assembly Language Programming: ARM Cortex-M0+ on the Raspberry PiPico; Apress: Berkeley, CA, USA, 2022; pp. 265-289.
71. PWCT Team. PWCT Features—Visual Programming. Available online: https://doublesvsoop.sourceforge.net/pwcthelp/features/visualprogramming.htm (accessed on 24 December 2024).
72. Bucanek, J. Model-view-controller pattern. Learn. Object.-C Java Dev.; 2009; 20, pp. 353-402.
73. Leff, A.; Rayfield, J.T. Web-application development using the model/view/controller design pattern. Proceedings of the Fifth IEEE International Enterprise Distributed Object Computing Conference; Seattle, WA, USA, 4–7 September 2001; pp. 118-127.
74. Bragge, M. Model-View-Controller Architectural Pattern and Its Evolution in Graphical User Interface Frameworks. Bachelor’s Thesis; Lappeenranta University of Technology: Lappeenranta, Finland, 2013.
75. Ahmed, Z.; Kinjol, F.J.; Ananya, I.J. Comparative analysis of six programming languages based on readability, writability, and reliability. Proceedings of the 2021 24th International Conference on Computer and Information Technology (ICCIT); Dhaka, Bangladesh, 18–20 December 2021; pp. 1-6.
76. des Rivieres, J.; Spencer, H. Readability and writability in Euclid. ACM Sigplan Not.; 1978; 13, pp. 49-56. [DOI: https://dx.doi.org/10.1145/954373.954378]
77. Vaithilingam, P.; Zhang, T.; Glassman, E.L. Expectation vs. experience: Evaluating the usability of code generation tools powered by large language models. Proceedings of the Chi Conference on Human Factors in Computing Systems Extended Abstracts; New Orleans, LA, USA, 29 April–5 May 2022; pp. 1-7.
78. Nystrom, R. Crafting Interpreters; Genever Benning: Mumbai, India, 2021.
79. Wilhelm, R.; Seidl, H. Compiler Design: Virtual Machines; Springer: Berlin/Heidelberg, Germany, 2010; Volume 10.
80. Plaisted, D.A. Source-to-source translation and software engineering. J. Softw. Eng. Appl.; 2013; 6, pp. 30-40. [DOI: https://dx.doi.org/10.4236/jsea.2013.64A005]
81. Lazar, G.; Penea, R. Mastering Qt 5: Create Stunning Cross-Platform Applications Using C++ with Qt Widgets and QML with Qt Quick; Packt Publishing, Ltd.: Birmingham, UK, 2018.
82. leClercq, A.; Almroth, K. Comparison of Rendering Performance Between Multimedia Libraries Allegro, SDL and SFML; KTH Royal Institute of Technology, School of Electrical Engineering and Computer Science: Stockholm, Sweden, 2019.
83. Steamplatform. PWCT2 Software. 2023; Available online: https://store.steampowered.com/app/1953110/Programming_Without_Coding_Technology_20/ (accessed on 24 December 2024).
84. Alohali, Y.A.; Fayed, M.S.; Mesallam, T.; Abdelsamad, Y.; Almuhawas, F.; Hagr, A. A Machine Learning Model to Predict Citation Counts of Scientific Papers in Otology Field. BioMed Res. Int.; 2022; 2022, 2239152. [DOI: https://dx.doi.org/10.1155/2022/2239152] [PubMed: https://www.ncbi.nlm.nih.gov/pubmed/35909490]
85. Fayed, M. Over 30 Videos to Learn PWCT. Available online: https://www.youtube.com/watch?v=zd2jUEIlr8Y&list=PLpQiqjcu7CuFFulJW0IdG8xmAXaDC2oC7 (accessed on 24 December 2024).
© 2025 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/). Notwithstanding the ProQuest Terms and Conditions, you may use this content in accordance with the terms of the License.
Details
; Alohali, Yousef A