Method for realizing visual programming

Abstract

The invention provides a method for realizing visual programming, and belongs to the technical field of visual programming, and the method comprises the following steps: determining different field requirements according to application fields, listing a programming normal form and a programming block type based on the field requirements, and designing an overall architecture corresponding to the application fields; specific functions of the programming blocks are determined based on the overall framework, the connection relation between the programming blocks is determined according to the specific functions, and then a core module of the corresponding application field is developed; a user interface and user interaction mode is designed in combination with the overall framework and the core module, so that a visual programming environment is formed, the programming threshold is lowered, the programming process is simplified, the user experience is improved, non-professional users can easily master the method through visual programming, the development efficiency is improved, and the requirement for user environment configuration is lowered.

Description

Technical Field

[0001] The present invention relates to the technical field of visual programming, and particularly to a method for implementing visual programming. Background Art

[0002] The use of traditional programming tools has relatively high requirements for the user's environment. Users need to configure corresponding development environments and dependency libraries, which may be an insurmountable threshold for non-professional users. At the same time, many traditional programming tools lack sufficient user-friendliness, with complex interfaces, resulting in user confusion during use and affecting programming efficiency.

[0003] Therefore, the present invention provides a method for implementing visual programming. Summary of the Invention

[0004] A method for implementing visual programming provided by the present invention determines requirements according to the application field, selects appropriate programming paradigms and programming block types, designs the overall architecture, designs the core modules based on the architecture, defines the functions and connection relationships of the programming blocks, designs the user interface and interaction methods, creates a complete visual programming environment, where users can create programs by dragging and connecting prefabricated programming blocks, and the system automatically generates code and runs, reducing the programming threshold, simplifying the programming process, improving the user experience. Through visual programming, non-professional users can easily get started, improve development efficiency, and reduce the requirements for user environment configuration.

[0005] The present invention provides a method for implementing visual programming, including: Step 1: Determine different field requirements according to the application field, list programming paradigms and programming block types based on the field requirements, and design the overall architecture corresponding to the application field; Step 2: Determine the specific functions of the programming blocks based on the overall architecture, clarify the connection relationships between the programming blocks according to the specific functions, and then develop the core modules corresponding to the application field; Step 3: Design the user interface and user interaction methods in combination with the overall architecture and the core modules, and then form a visual programming environment.

[0006] The present invention provides a method for implementing visual programming, which determines different field requirements according to the application field, lists programming paradigms and programming block types based on the field requirements, and designs the overall architecture corresponding to the application field, including: Expand keywords for the application field, and determine the key participants in the corresponding application field according to the keyword expansion results; Obtain the existing systems in the application field based on the key participants, perform a first analysis on the key participants and the existing systems, and obtain the field requirements in the corresponding application field according to the first analysis results; Perform a second parsing on the existing system based on the requirements of the field, and list the programming paradigms and programming block types. Construct the overall architecture of the application field in combination with the requirements of the field, programming paradigms, and programming block types.

[0007] The present invention provides a method for implementing visual programming. Expand keywords for the application field, and determine the key participants in the corresponding application field according to the keyword expansion results, including: Perform a first keyword expansion with the application field as the first keyword, and determine the research direction of the application field according to the first expansion result. Perform a second keyword expansion on the first expansion result based on the research direction, and search for the key participants in the application field according to the second expansion result.

[0008] The present invention provides a method for implementing visual programming. Based on the overall framework, determine the specific functions of the programming blocks, clarify the connection relationships between the programming blocks according to the specific functions, and then develop the core module of the corresponding application field, including: Clarify the design goals of the overall architecture based on the field requirements, determine the identification principle according to the design goals, use the identification principle to perform domain identification on the overall framework, and decompose the overall architecture into subunits. Perform a functional analysis on the subunits, and determine the programming blocks of the subunits and the specific functions corresponding to each programming block according to the functional analysis results. Determine the connection relationships between the programming blocks based on the specific functions and programming paradigms. Design the UI appearance and interaction method of each subunit according to the specific functions and connection relationships, clarify the internal logic of each subunit using C# scripts, and then create the graphical programming unit of each subunit. Develop the core module of the corresponding application field by integrating all the graphical programming unit groups.

[0009] The present invention provides a method for implementing visual programming. Design the UI appearance and interaction method of each subunit according to the specific functions and connection relationships, including: Select UI elements based on the specific functions and connection relationships, list all the information that needs to be displayed on the subunit UI, sort the information according to the importance level, and generate an input set and an output set according to the sorting results. Perform a level division on the information according to the sorting results, and determine the hierarchical relationship between the information according to the level division results. Design the information framework by integrating the input set, output set, and hierarchical relationship. Match the corresponding layout scheme from the information architecture - layout table according to the information architecture design result, draw wireframes of different layout schemes using a wireframing tool, and create an interactive prototype using a prototyping tool; Construct the UI appearance and interaction method of each subunit based on the wireframe and the interactive prototype.

[0010] The present invention provides a method for implementing visual programming. Use C# scripts to clarify the internal logic of each subunit, and then create graphical programming blocks for each subunit, including: Design a C# class for each subunit, define the properties in the C# class to represent the programming parameters in the subunit, and process the internal logic of the subunit according to the methods in the C# class; Logically connect the subunits based on the processing results, add a visual feedback mechanism to the UI appearance, interaction method, and logical connection results to form graphical programming units for each subunit.

[0011] The present invention provides a method for implementing visual programming. Combine the overall architecture and core modules to design the user interface and user interaction method, and then form a visual programming environment, including: Based on the overall architecture and core modules, clarify the basic goals of the user interface design and interaction method; Identify different types of users, analyze the users' skill levels, usage habits, and target tasks, and determine the user portraits; Design the main work area based on the basic goals, and design a programming block panel and corresponding property panel in the main work area to form the user interface; Set the interaction method for the user interface according to the user portraits to form a visual programming environment.

[0012] The present invention provides a method for implementing visual programming. Set the interaction method for the user interface according to the user portraits to form a visual programming environment, including: Refine the user characteristics of different user types according to the existing user portraits, analyze the main tasks that each user type will perform when using the visual programming environment based on the user characteristics, and decompose the main tasks; Set the interaction method for each user type according to the decomposition results to form a visual programming environment.

[0013] Compared with the prior art, the beneficial effects of the present application are as follows: By determining requirements according to the application field, selecting appropriate programming paradigms and programming block types, designing the overall architecture, designing core modules based on the architecture, defining the functions and connection relationships of programming blocks, designing the user interface and interaction methods, and creating a complete visual programming environment, users can create programs by dragging and connecting prefabricated programming blocks, and the system automatically generates code and runs, reducing the programming threshold, simplifying the programming process, and improving the user experience. Through visual programming, non-professional users can also easily get started, improve development efficiency, and reduce the requirements for user environment configuration.

[0014] Other features and advantages of the present invention will be described in the following specification, and, in part, will be obvious from the specification, or will be understood by implementing the present invention. The objectives and other advantages of the present invention can be achieved and obtained by the structures specifically pointed out in the written specification and the drawings.

[0015] The technical solutions of the present invention will be further described in detail below through the drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] The drawings are used to provide a further understanding of the present invention, and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention, and do not constitute a limitation to the present invention. In the drawings: Figure 1 is a schematic flowchart of a method for implementing visual programming provided by an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0017] The following describes the preferred embodiments of the present invention with reference to the drawings. It should be understood that the preferred embodiments described herein are only for the purpose of illustrating and explaining the present invention, and are not intended to limit the present invention.

[0018] Embodiment 1: An embodiment of the present invention provides a method for implementing visual programming, as Figure 1 shown, including: Step 1: Determine different domain requirements according to the application field, list programming paradigms and programming block types based on the domain requirements, and design the overall architecture for the corresponding application field; Step 2: Determine the specific functions of programming blocks based on the overall architecture, clarify the connection relationships between programming blocks according to the specific functions, and then develop the core modules for the corresponding application field; Step 3: Design the user interface and user interaction method in combination with the overall architecture and core modules, and then form a visual programming environment.

[0019] In this embodiment, the application domain is a specific industry or field, and computer programming technology is applied to solve problems or provide services. For example, software development, game development, data science, artificial intelligence, web development, etc.

[0020] In this embodiment, the domain requirements are the needs of users and the market for products, services, or technologies in a specific application domain. For example, in the "artificial intelligence" domain, the requirements may include efficient algorithms, interpretable models, data privacy protection, etc.

[0021] In this embodiment, the programming paradigm is the style or methodology of programming, including how to organize code and solve problems. For example, object-oriented programming (OOP), functional programming (FP), imperative programming, logic programming, etc.

[0022] In this embodiment, the programming block type is the type of modules or components commonly used in programming, usually used to build the foundation of an application. For example, data processing modules, user interface components, database interaction modules, API interface modules, etc.

[0023] In this embodiment, the overall architecture is a system architecture design formed by integrating domain requirements, programming paradigms, and programming block types. For example, in the "web development" domain, the overall architecture may include a microservices-based application, with React or Vue.js used for the front end, Node.js and Express used for the back end, MongoDB used for the database, the API adopting the RESTful style, and CI / CD tools used for continuous integration and deployment.

[0024] In this embodiment, the specific functions are the specific operations required for each function of the subunit. For example, for the user registration function: verify user input, store user information in the database, and send a confirmation email; for the data analysis function: read data files, perform statistical calculations, and generate charts.

[0025] In this embodiment, the connection relationship is the interaction and communication method between different programming blocks. For example, the connection between user management and data analysis: the user management module needs to provide user data to the data analysis module, which may be achieved through an API or database query.

[0026] In this embodiment, the core modules are the set of modules that implement the main functions in the application domain. For example, in software development: the core modules may include a user management module, a data storage module, and a business logic module; in data science: the core modules may include a data processing module, an analysis module, and a visualization module.

[0027] In this embodiment, starting from the domain requirements, the design goals are clarified, the identification principles are formulated, the overall architecture is decomposed into sub-units. For each sub-unit, the functions are analyzed, the programming blocks are designed, the connection relationships are defined, the UI and internal logic are implemented, and finally, graphical programming units are created and all the units are assembled into a core module.

[0028] In this embodiment, the interaction method setting is the way for users to interact with the interface, including mouse operations, touch gestures, etc. For example, users can move programming blocks from the programming block panel to the main work area through drag-and-drop operations, or modify parameters by clicking on the input box in the property panel.

[0029] The working principle and beneficial effects of the above technical solution are as follows: By determining the requirements according to the application domain, selecting appropriate programming paradigms and programming block types, designing the overall architecture, designing the core module based on the architecture, defining the functions and connection relationships of the programming blocks, designing the user interface and interaction method, a complete visual programming environment is created. Users can create programs by dragging and connecting prefabricated programming blocks, and the system automatically generates code and runs it, which reduces the programming threshold, simplifies the programming process, and improves the user experience. Through visual programming, non-professional users can also easily get started, improve development efficiency, and reduce the requirements for user environment configuration.

[0030] Embodiment 2: An embodiment of the present invention provides a method for implementing visual programming. Different domain requirements are determined according to the application domain, programming paradigms and programming block types are listed based on the domain requirements, and the overall architecture of the corresponding application domain is designed, including: Expand keywords for the application domain, and determine the key participants in the corresponding application domain according to the keyword expansion results; Based on the key participants, obtain the existing systems in the application domain, perform a first analysis on the key participants and the existing systems, and obtain the domain requirements of the corresponding application domain according to the first analysis results; Perform a second analysis on the existing systems based on the domain requirements, and list the programming paradigms and programming block types; Construct the overall architecture of the application domain by combining the domain requirements, programming paradigms and programming block types.

[0031] In this embodiment, keyword expansion is to identify the themes, technologies and trends related to the application domain through the expansion of relevant keywords. For example, for the "Web development" domain, keywords such as "front-end framework", "back-end service", "API design", "responsive design" can be expanded.

[0032] In this embodiment, the key participants are organizations, companies, or individuals with significant influence in a specific application domain. For example, in the "software development" domain, the key participants may include Microsoft, Google, GitHub, Stack Overflow, etc.

[0033] In this embodiment, the existing system is a collection of current technologies, tools, platforms, and solutions in a specific domain. For example, in the "data science" domain, the existing system may include Python, R, TensorFlow, Jupyter Notebook, etc.

[0034] In this embodiment, the first analysis is a preliminary analysis of the key participants and the existing system to identify their interrelationships and functions. For example, analyze how GitHub integrates with open-source projects and CI / CD tools (such as Jenkins) to facilitate collaboration and version control in software development.

[0035] In this embodiment, the second analysis is an in-depth analysis of the existing system based on domain requirements to identify specific technologies and tools. For example, analyze how to use machine learning libraries (such as Scikit-learn) to meet specific prediction requirements in the data science domain.

[0036] The working principle and beneficial effects of the above technical solution are as follows: By keyword expansion, identify the key participants and the existing system in the application domain. Through the first and second analyses of the participants and the existing system, extract domain requirements, determine the appropriate programming paradigm and programming block type, and build the overall architecture in combination with the requirements, paradigm, and block type, improving user-friendliness, reducing environmental configuration requirements, and enhancing development efficiency.

[0037] Embodiment 3: The embodiment of the present invention provides a method for implementing visual programming, which performs keyword expansion on the application domain and determines the key participants in the corresponding application domain according to the keyword expansion result, including: Perform the first keyword expansion with the application domain as the first keyword, and determine the research direction of the application domain according to the first expansion result; Perform the second keyword expansion on the first expansion result based on the research direction, and search for the key participants in the application domain according to the second expansion result.

[0038] In this embodiment, the first expansion is a keyword expansion around the application domain to identify relevant topics, technologies, and trends. For example, software development: agile development, continuous integration / continuous deployment (CI / CD), microservices architecture, DevOps, version control.

[0039] In this embodiment, the research direction is a specific research field or technical direction identified based on the first expansion result. For example, in software development: researching the application of agile methodology in team collaboration.

[0040] In this embodiment, the second expansion is a further keyword expansion of the first expansion result based on the research direction to identify relevant technologies, tools, and trends. For example, in software development: agile tools (such as JIRA, Trello), CI / CD tools (such as Jenkins, GitHub Actions), microservices frameworks (such as Spring Boot, Docker).

[0041] In this embodiment, the key players are organizations, companies, or individuals with significant influence in a specific application domain. For example, in software development: Microsoft, Atlassian (JIRA), GitHub, GitLab.

[0042] The working principle and beneficial effects of the above technical solution are as follows: By expanding with the application domain as the keyword, the research direction of this domain is determined. Based on the research direction, keyword expansion is carried out again to find the key players in this domain, which helps to quickly identify key players, shorten the requirements analysis time, lower the threshold for the development of the visual programming system, and improve user-friendliness.

[0043] Embodiment 4: An embodiment of the present invention provides a method for implementing visual programming. Based on the overall architecture, the specific functions of the programming blocks are determined. According to the specific functions, the connection relationships between the programming blocks are clarified, and then the core module of the corresponding application domain is developed, including: Based on the domain requirements, the design goals of the overall architecture are clarified. According to the design goals, the identification principle is determined, and the overall architecture is domain-identified using the identification principle, and the overall architecture is decomposed into subunits; Perform a function analysis on the subunits. According to the function analysis results, determine the programming blocks of the subunits and the specific functions corresponding to each programming block; Based on the specific functions and programming paradigms, determine the connection relationships between the programming blocks; According to the specific functions and connection relationships, design the UI appearance and interaction methods of each subunit, and use C# scripts to clarify the internal logic of each subunit, and then create the graphical programming units of each subunit; Integrate all the graphical programming unit groups to develop the core module of the corresponding application domain.

[0044] In this embodiment, the design goal is to clarify the purposes and requirements that the overall architecture should achieve. For example, in software development: build a scalable and easy-to-maintain application that supports concurrent access by multiple users; in data science: create a user-friendly data analysis platform that can handle large-scale data sets and provide visualization functions.

[0045] In this embodiment, the identification principle is the principle used to identify and define each component in the system. For example, modularity: each sub-unit should be independent with clear functions, high cohesion, and low coupling: the functions within the sub-units are closely related, and the dependencies between sub-units are minimized as much as possible.

[0046] In this embodiment, the domain identification is to classify and identify the overall architecture for easy management and understanding. For example, the user management domain: handles user registration, login, and permission management; the data processing domain: is responsible for data input, cleaning, and analysis.

[0047] In this embodiment, the sub-units are to break down the overall architecture into smaller and manageable parts. For example, the user management sub-unit: is responsible for create, read, update, and delete (CRUD) operations of user information; the data analysis sub-unit: is responsible for statistical analysis and visualization of data.

[0048] In this embodiment, the functional analysis is to refine the functions of each sub-unit and identify its specific responsibilities. For example, the functions of the user management sub-unit: user registration, user login, user information update, and password reset.

[0049] In this embodiment, the UI appearance and interaction method are the design of the user interface and the way users interact with the system. For example, the user management interface: includes a registration form, a login box, and a user information page, and uses buttons, input boxes, and prompt messages for interaction; the data analysis interface: provides a data upload function, an analysis result display area, and visualization charts.

[0050] In this embodiment, the graphical programming unit is programming blocks displayed through a graphical interface, which is convenient for users to understand and operate. For example, the graphical unit for user registration: includes an input box and a button, and connects each function module by dragging; the graphical unit for data analysis: visualizes the data flow and calculation process, and users can configure analysis parameters through the graphical interface.

[0051] In this embodiment, based on the functions and connection relationships of the programming blocks, select appropriate UI elements, sort and rank the information displayed on the UI, design the information architecture, select an appropriate scheme from the predefined layout schemes according to the information architecture, and use wireframe and prototype tools for design and testing, and finally determine the UI appearance and interaction method.

[0052] In this embodiment, a C# class is created for each subunit. The attributes of the class are used to represent programming parameters, and the methods of the class are used to implement the internal logic of the subunit. Based on the processing results, the logical connections between subunits are defined, and the UI appearance, interaction methods, and logical connection results are associated through a visual feedback mechanism (e.g., connection lines, color changes, etc.), finally forming a graphical programming unit.

[0053] The working principle and beneficial effects of the above technical solution are as follows: Starting from the domain requirements, the design goals are clarified, the identification principles are formulated, the overall architecture is decomposed into subunits. For each subunit, the functions are analyzed, the programming blocks are designed, the connection relationships are defined, the UI and internal logic are implemented, and finally a graphical programming unit is created. All the units are assembled into a core module to improve the maintainability, scalability, and reusability of the system.

[0054] Embodiment 5: The embodiment of the present invention provides a method for implementing visual programming. The UI appearance and interaction methods of each subunit are designed according to the specific functions and connection relationships, including: Select UI elements based on the specific functions and connection relationships, list all the information that needs to be displayed on the subunit UI, sort the information according to the importance level, and generate an input set and an output set according to the sorting results; Classify the information according to the sorting results, and determine the hierarchical relationship between the information according to the classification results; Design an information architecture by integrating the input set, output set, and hierarchical relationship; Match the corresponding layout scheme from the information architecture - layout table according to the information architecture design results, draw wireframes of different layout schemes using a wireframing tool, and create an interactive prototype using a prototyping tool; Construct the UI appearance and interaction methods of each subunit according to the wireframes and interactive prototype.

[0055] In this embodiment, UI elements are components used for interacting with users in the user interface. For example, buttons: used to submit forms or perform operations, input boxes: places where users enter information, such as usernames and passwords, dropdown menus: used to select options, such as selecting the data analysis type, labels: texts used to describe input boxes or information.

[0056] In this embodiment, the sorting result is the result of sorting the information according to the importance level. For example, username (required), password (required), email (optional), user role (optional).

[0057] In this embodiment, the input set is a set of information that users need to input. For example, username, password, email, user role.

[0058] In this embodiment, the output set is the set of information presented by the system to the user. For example, login success prompt, login failure prompt, user information overview (such as name, role).

[0059] In this embodiment, the level classification is the classification of information according to importance or priority. For example, first-level information: username, password (must be entered), second-level information: email, user role (optional).

[0060] In this embodiment, the hierarchical relationship is the priority and dependency relationship between information. For example, first-level information (username, password) is the basis for login and must be displayed first, and second-level information (email, user role) can be optionally displayed after login.

[0061] In this embodiment, the information architecture is the structure for organizing and arranging information, clarifying input and output. For example, input information: username, password, output information: login status (success or failure), user role.

[0062] In this embodiment, the information architecture - layout table is a table that matches the information architecture with the layout scheme.

[0063] In this embodiment, the layout scheme is the specific arrangement for presenting information. For example, vertical layout: input boxes and buttons are arranged vertically, grid layout: information is arranged in a grid form, suitable for complex forms.

[0064] In this embodiment, the wireframe tool is a tool for drawing interface layouts. For example, tools: Figma, Sketch, Balsamiq, uses: quickly create the basic layout of the interface and display the arrangement of information.

[0065] In this embodiment, the wireframe is a sketch showing the layout of the user interface, emphasizing functionality rather than visual design. For example, the wireframe of the login page: includes input boxes, buttons, and information prompt areas.

[0066] In this embodiment, the interactive prototype is a clickable model that simulates user interaction with the interface. For example, a login page prototype created using Figma or Axure, where users can click buttons, enter information, and view feedback.

[0067] In this embodiment, the UI appearance and interaction method are the visual design of the user interface and the interaction method between the user and the system. For example, appearance: using modern minimalist color schemes, fonts, and icons, interaction method: click the button to submit the form, use a prompt box to display error messages, and the input box has real-time verification functionality.

[0068] The working principle and beneficial effects of the above technical solution are as follows: Based on the functions and connection relationships of programming blocks, appropriate UI elements are selected, and the information displayed on the UI is sorted and graded. An information architecture is designed, and a suitable scheme is selected from predefined layout schemes according to the information architecture. Wireframing and prototyping tools are used for design and testing, and finally the UI appearance and interaction method are determined, improving the efficiency and quality of UI design, more intuitively presenting the UI design, facilitating communication with team members, and discovering and solving design problems as early as possible.

[0069] Embodiment 6: The embodiment of the present invention provides a method for implementing visual programming. C# scripts are used to clarify the internal logic of each subunit, and then graphical programming blocks for each subunit are created, including: Design a C# class for each subunit, define the properties in the C# class to represent the programming parameters in the subunit, and process the internal logic of the subunit according to the methods in the C# class; Based on the processing results, the subunits are logically connected, and a visual feedback mechanism is added to the UI appearance and interaction method and the logical connection results to form graphical programming units for each subunit.

[0070] In this embodiment, the C# class is a blueprint for an object, containing properties and methods for encapsulating data and behavior. For example, in a user login system, a User class can be designed to represent user information.

[0071] In this embodiment, the programming parameter is a property in the class, used to store the state or characteristics of the object. For example, in the User class, properties such as Username, Password, and Email are programming parameters, representing the basic information of the user.

[0072] In this embodiment, the internal logic is a method in the class, used to implement specific functions or process data. For example, in the User class, the ValidateCredentials method is used to verify the validity of the username and password, which is the implementation of the internal logic.

[0073] In this embodiment, the logical connection is to connect different classes or objects through method calls or event handling to achieve functional interaction. For example, in the AuthService class, the Login method calls the ValidateCredentials method of the User class to complete the logical connection for user login.

[0074] In this embodiment, the visual feedback mechanism is a mechanism for providing feedback on the results of user operations on the user interface, which is usually implemented by means of color changes, prompt messages, animations, etc. For example, in UI classes (such as LoginWindow), if the user enters an incorrect username or password, an error message can be displayed and the border color of the input box can be changed to provide visual feedback.

[0075] The working principle and beneficial effects of the above technical solution are as follows: create a C# class for each sub-unit, use the properties of the class to represent programming parameters, use the methods of the class to implement the internal logic of the sub-unit, define the logical connections between sub-units based on the processing results, and associate the UI appearance, interaction method, and logical connection results through a visual feedback mechanism (such as connection lines, color changes, etc.), finally forming a graphical programming unit, which improves the maintainability and reusability of the code, makes the code easier to understand and modify. At the same time, it is convenient for users to understand the running state and data flow of the program.

[0076] Embodiment 7: The embodiment of the present invention provides a method for implementing visual programming, which combines the overall framework and core modules to design the user interface and user interaction method, and then forms a visual programming environment, including: Based on the overall architecture and core modules, clarify the basic goals of the user interface design and interaction method; Identify different types of users, analyze the users' skill levels, usage habits, and target tasks, and determine the user portraits; Based on the basic goals, design the main work area, and design a programming block panel and corresponding property panel in the main work area, and then form a user interface; Set the interaction method for the user interface according to the user portraits to form a visual programming environment.

[0077] In this embodiment, the basic goal is the main purpose and expected result of designing the user interface, which usually includes improving the user experience, enhancing usability, and increasing work efficiency. For example, in a visual programming environment, the basic goal may be to enable users to quickly build program logic by dragging and dropping programming blocks without having to write code manually.

[0078] In this embodiment, the skill level is the proficiency of users in using specific tools or technologies, which is usually divided into beginner, intermediate, and advanced levels. For example, beginner users may be unfamiliar with programming concepts, while advanced users can quickly understand and use complex programming blocks; usage habits are the common behaviors and preferences of users when using software. For example, some users may be accustomed to using shortcut keys, while others prefer to operate through menus. The target task is the specific task that users hope to complete through the software. For example, users may hope to create a simple game or write a data processing program through a visual programming environment.

[0079] In this embodiment, a user profile is a detailed description of a target user, including their skill level, usage habits, target tasks, and other characteristics. For example, a user profile might be described as: beginner, 20 years old, likes to learn programming by drag-and-drop, aims to create simple 2D games, and is used to interacting with a touch device.

[0080] In this embodiment, different types of users are user groups divided according to the user's background, needs, and behavior. For example, beginners: not familiar with programming, rely on visual tools; intermediate users: have a certain programming foundation and can understand programming logic; advanced users: proficient in programming and may wish to customize functions more deeply.

[0081] In this embodiment, the main work area is the main area of the user interface where users perform main operations, such as dragging and dropping programming blocks. For example, in a visual programming environment, the main work area might be a large canvas where users can place and connect programming blocks.

[0082] In this embodiment, the property panel is the interface part used to display and edit the properties of a selected programming block. For example, when a user selects a programming block, the property panel might display the parameters of the block, such as variable name, data type, etc., and the user can directly modify them in this panel.

[0083] In this embodiment, the programming block panel is a panel containing available programming blocks from which users can drag and drop blocks into the main work area. For example, the programming block panel might contain blocks such as "loop", "condition", "variable", etc., and users can build program logic by dragging these blocks into the work area.

[0084] In this embodiment, the user interface is the visual and functional design for users to interact with the software. For example, in a visual programming environment, the user interface might include the main work area, programming block panel, property panel, toolbar, etc.

[0085] In this embodiment, a visual programming environment is an environment that allows users to program through a graphical interface rather than text code. For example, like Scratch or Blockly, users can create program logic by dragging and dropping programming blocks, which is suitable for beginners and educational purposes.

[0086] The working principle and beneficial effects of the above technical solution are as follows: Based on the system architecture and core modules, the basic goals of user interface design and interaction are determined, and user portraits are created to understand the needs of different users. Based on the goals and user portraits, the main work area, programming block panel, and property panel are designed, and the drag-and-drop operations are processed using the Unity event system to construct the user interface. The interaction method is set according to the user portrait to form a visual programming environment, which helps to simplify the development process and improve efficiency, taking into account both usability and functionality, enhancing the user experience, and reducing the development difficulty.

[0087] Embodiment 8: An embodiment of the present invention provides a method for implementing visual programming. The interaction method of the user interface is set according to the user portrait to form a visual programming environment, including: According to the existing user portraits, refine the user characteristics of different user types, analyze the main tasks that each user type will perform when using the visual programming environment based on the user characteristics, and decompose the main tasks; Set the interaction method of each user type according to the decomposition result, thereby forming a visual programming environment.

[0088] In this embodiment, the user characteristics refer to the specific attributes and behavior habits of different user types when using the visual programming environment. For example, beginners: characteristics: not familiar with programming concepts, relying on an intuitive drag-and-drop interface, preferring to learn through tutorials; preferences: simple interface, intuitive feedback, visual guidance; intermediate users: characteristics: having a certain programming foundation, able to understand programming logic, liking to explore new functions; preferences: being able to quickly access advanced functions, liking customization; advanced users: characteristics: proficient in programming, able to understand complex programming concepts, liking to carry out in-depth project development; preferences: supporting code editing and debugging functions, being able to quickly switch to the code view.

[0089] In this embodiment, the main task is the core activity that the user hopes to complete when using the visual programming environment. For example, beginners: main tasks: learning basic programming concepts, creating simple projects (such as small games), and learning using tutorials and examples.

[0090] In this embodiment, the decomposition result is to break down the main tasks into smaller and more specific steps or activities. For example, beginners: learning basic programming concepts: watching video tutorials, completing interactive exercises; creating simple projects: selecting a template, dragging and dropping programming blocks into the work area, running and testing the project.

[0091] In this embodiment, the interaction method for user types is the way users interact with the visual programming environment, including operation and feedback mechanisms. For example, for beginners: Interaction method: Drag and drop programming blocks into the main workspace, use tooltips and help documents, and start tutorials and examples through buttons; For intermediate users: Interaction method: Use shortcut keys to access common functions, customize the interface layout, and use the search function to find programming blocks.

[0092] The working principle and beneficial effects of the above technical solution are as follows: Based on the existing user portraits, refine the characteristics of different user types, analyze the main tasks of each user type in the visual programming environment, break down these tasks into smaller subtasks, and design different interaction methods for each user type according to the characteristics of these subtasks and the user's skill level. Finally, a visual programming environment that adapts to different user needs is formed, meeting the needs of users with different skill levels, making the visual programming environment more inclusive and user-friendly.

[0093] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit them. Although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that they can still modify the technical solutions recorded in the foregoing embodiments or equivalently replace some of the technical features. However, such modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for implementing visual programming, characterized in that: include: Step 1: Determine different domain requirements according to the application domain, list programming paradigms and programming block types based on the domain requirements, and design the overall architecture of the corresponding application domain; Step 2: Determine the specific functions of the programming blocks based on the overall architecture, clarify the connection relationship between the programming blocks according to the specific functions, and then develop the core modules of the corresponding application fields; Step 3: Design the user interface and user interaction method in combination with the overall framework and core modules, thereby forming a visual programming environment.

2. A method for implementing visual programming according to claim 1, characterized in that: Determine different domain requirements according to the application domain, list programming paradigms and programming block types based on the domain requirements, and design the overall architecture of the corresponding application domain, including: Expand keywords for application fields and determine key players in corresponding application fields based on the results of keyword expansion; Acquiring an existing system of the application field based on the key participant, performing a first analysis on the key participant and the existing system, and obtaining a field requirement of the corresponding application field according to the first analysis result; Perform a second analysis of the existing system based on the domain requirements, and list programming paradigms and programming block types; The overall architecture of the application domain is constructed by combining the domain requirements, programming paradigms and programming block types.

3. A method for implementing visual programming according to claim 2, characterized in that: Expand the keywords of the application field and determine the key players in the corresponding application field based on the keyword expansion results, including: Perform a first keyword expansion with the application field as the first keyword, and determine the research direction of the application field according to the first expansion result; Based on the research direction, a second keyword expansion is performed on the first expansion result, and key participants in the application field are searched according to the second expansion result.

4. A method for implementing visual programming according to claim 1, characterized in that: Based on the overall framework, the specific functions of the programming blocks are determined, and the connection relationship between the programming blocks is clarified according to the specific functions, and then the core modules of the corresponding application fields are developed, including: Based on the domain requirements, the design goals of the overall architecture are clarified, the identification principles are determined according to the design goals, the domains of the overall architecture are identified using the identification principles, and the overall architecture is decomposed into sub-units; Performing functional analysis on the subunit, and determining the programming blocks of the subunit and the specific functions corresponding to each programming block according to the functional analysis results; Determine the connection relationship between programming blocks based on the specific functions and programming paradigm; Design the UI appearance and interaction mode of each sub-unit according to the specific functions and connection relationships, use C# scripts to clarify the internal logic of each sub-unit, and then create a graphical programming unit for each sub-unit; Integrate all graphical programming units to develop core modules for corresponding application areas.

5. A method for implementing visual programming according to claim 4, characterized in that: Design the UI appearance and interaction mode of each sub-unit according to the specific functions and connection relationships, including: Select UI elements based on specific functions and connection relationships, list all information that needs to be displayed on the sub-unit UI, sort the information according to importance, and generate input sets and output sets based on the sorting results; Classify the information according to the sorting result, and determine the hierarchical relationship between the information according to the classification result; Designing an information architecture by integrating the input set, output set and hierarchical relationship; According to the information architecture design results, match the corresponding layout scheme from the information architecture-layout table, use the wireframe tool to draw wireframes of different layout schemes, and use the prototyping tool to create interactive prototypes; The UI appearance and interaction mode of each sub-unit are constructed according to the wireframe diagram and interactive prototype.

6. A method for implementing visual programming according to claim 5, characterized in that: Use C# scripts to clarify the internal logic of each sub-unit, and then create graphical programming blocks for each sub-unit, including: Design a C# class for each sub-unit, define the properties in the C# class to represent the programming parameters in the sub-unit, and process the internal logic of the sub-unit according to the methods in the C# class; The sub-units are logically connected based on the processing results, and a visual feedback mechanism is added to the UI appearance and interaction mode and the logical connection results to form a graphical programming unit for each sub-unit.

7. A method for implementing visual programming according to claim 1, characterized in that: Combining the overall architecture with the core modules, the user interface and user interaction method are designed to form a visual programming environment, including: Based on the overall architecture and core modules, clarify the basic goals of user interface design and interaction methods; Identify different types of users, analyze their skill levels, usage habits, and target tasks, and determine user profiles; Designing a main workspace based on the basic target, and designing a programming block panel and a corresponding property panel in the main workspace to form a user interface; The user interface is interactively configured according to the user portrait to form a visual programming environment.

8. A method for implementing visual programming according to claim 1, characterized in that: The user interface is interactively set according to the user portrait to form a visual programming environment, including: According to the existing user portraits, the user characteristics of different user types are refined, and based on the user characteristics, the main tasks that each user type will perform when using the visual programming environment are analyzed, and the main tasks are decomposed; The interaction mode of each user type is set according to the decomposition results, thereby forming a visual programming environment.

Images