Multi-person collaborative programming method and system, electronic equipment and medium

Abstract

The invention discloses a multi-person collaborative programming method and system, electronic equipment and a medium, and the method comprises the steps: providing a canvas task designer which supports the visual design of a plurality of canvases, and enabling each canvas to correspond to a subtask; sub-tasks designed in one or more canvases are stored as independent module files, and each module file can be developed by different developers; persistently storing the developed module file locally, and creating a module ID for the module file; and importing each module file into a unified project, and editing a data reference relationship and execution logic among the module files. According to the multi-person collaborative programming method and system, the electronic equipment and the medium provided by the invention, the whole project is divided into a plurality of independent sub-tasks through the canvas task designer, and each sub-task is stored in the form of the module file and can be independently developed by different developers.

Description

Technical Field

[0001] The present invention belongs to the field of forming development technology, and specifically relates to a method, system, electronic equipment and medium for multi-person collaborative programming. Background Art

[0002] With the development of information technology and the diversification of application scenarios, low-code software and configuration software have become important tools for modern software development. These software, with their visual operation interface, modular development methods and rapid deployment capabilities, have significantly lowered the technical threshold for developers and are widely used in enterprise management, industrial control, intelligent manufacturing and other fields. However, existing low-code software and configuration software still have some limitations and problems in actual use, especially in multi-person collaborative development and modular management.

[0003] At present, the mainstream low-code software or configuration software on the market usually adopts the form of project directory tree for development and management. Under this structure, a project will generate a series of related user files, including interface files, data files, etc. These files are organized into an organic whole through the project directory tree. Although this method has certain convenience in single-person development or small-scale projects, its design and operation logic determine that these files are highly coupled with each other and cannot be used or deleted separately. This file organization method not only limits the flexibility of the project, but also poses challenges to the scalability and maintainability of the project.

[0004] Therefore, it is necessary to provide a new solution to the above technical problems. Summary of the invention

[0005] The purpose of the present invention is to provide a method, system, electronic device and medium for multi-person collaborative programming, which can solve the problems of poor portability, difficulty in collaboration among multiple developers, and insufficient modular support.

[0006] To achieve the above purpose, the technical solution provided by the present invention is as follows:

[0007] In a first aspect, the present invention provides a method for multi-person collaborative programming, which includes: providing a canvas task designer that supports visual design of multiple canvases, each canvas corresponding to a subtask; saving the subtasks designed in a single or multiple canvases as independent module files, and each module file can be developed by different developers; persistently storing the developed module files locally, and creating a module ID for the module files; importing each module file into a unified project engineering, editing the data reference relationship and execution logic between each module file, and completing the collaborative programming of the project engineering.

[0008] In one or more embodiments, the method further includes: creating a canvas display control, wherein the canvas display control is used to display attribute information of an object within the canvas, wherein the attribute information includes object name, input data name, output data name, input node, output node, whether configured, whether a breakpoint exists, whether locked, whether disabled, and a node color used to characterize a data type.

[0009] In one or more embodiments, the method further includes: creating operator objects corresponding to the subtasks in the canvas, configuring each operator object based on the attribute information displayed by the canvas display control, and setting data reference relationships and logical relationships between each operator object.

[0010] In one or more embodiments, the method further includes: recording each operator object and its attributes and operator ID, and recording the sequence and reference relationship between operators; persisting the operator object file and the canvas resource file locally, and saving them as module files that can be imported into the project. In one or more embodiments, importing each module file into a unified project includes: detecting whether there is a conflict between the module ID of the imported module file and the module ID of the existing module file in the project; if there is a conflict, modifying the module ID of the imported module file or replacing the existing module file with the conflict with the imported module file.

[0011] In one or more embodiments, the method further includes: detecting whether the operator ID of the operator object in the imported module file conflicts with the operator ID of the existing operator object in the project; if there is a conflict, modifying the operator ID of the operator object in the imported module file or replacing the existing operator object with the imported operator object.

[0012] In one or more implementations, the operator ID of the operator object in the imported module file is modified, including: adding a prefix, a suffix, a sequence number or a character to the original operator ID.

[0013] In the second aspect, the present invention provides a multi-person collaborative programming system, which includes: a canvas unit, a module unit, a persistence unit and an import unit; the canvas unit is used to provide a canvas task designer that supports multiple canvas visualization design, each canvas corresponds to a subtask; the module unit is used to save the subtasks designed in a single or multiple canvases as an independent module file, and each module file can be developed by different developers; the persistence unit is used to persist the developed module file locally and create a module ID for the module file; the import unit is used to import each module file into a unified project engineering, edit the data reference relationship and execution logic between each module file, and complete the collaborative programming of the project engineering.

[0014] In a third aspect, the present invention provides an electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the multi-person collaborative programming method as described above when executing the program.

[0015] In a fourth aspect, the present invention provides a computer-readable medium, wherein the computer-readable medium carries computer-executable instructions, and when the computer-executable instructions are executed by a processor, they are used to implement the method of multi-person collaborative programming as described above.

[0016] Compared with the prior art, the method, system, electronic device and medium for multi-person collaborative programming provided by the present invention divide the entire project into multiple independent subtasks through a canvas task designer. The subtasks are saved in the form of module files and can be independently developed by different developers. The persistent storage of module files and the creation of module IDs ensure the independence and uniqueness of the modules, support cross-project reuse and version management, and reduce the cost of repeated design. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the prior art descriptions are briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in the present invention, and for ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0018] Figure 1 A flowchart of a method for multi-person collaborative programming in one embodiment of the present invention;

[0019] Figure 2 This is a schematic diagram of the interface of a canvas task designer in one embodiment of the present invention;

[0020] Figure 3 It is a structural block diagram of a multi-person collaborative programming system in one embodiment of the present invention;

[0021] Figure 4 FIG. 4 is a structural block diagram of an electronic device in an embodiment of the present invention. DETAILED DESCRIPTION

[0022] In order to enable those skilled in the art to better understand the technical solutions in the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of the present invention.

[0023] As software development needs become more diverse and complex, low-code development platforms have gradually become mainstream tools. However, traditional low-code platforms usually adopt the management mode of project directory tree. Although this structure has certain advantages when dealing with small projects, its limitations are gradually revealed in complex projects. The high coupling between files makes it difficult to separate modules independently, and poor mobility makes it difficult to reuse functions. In the process of collaborative development by multiple people, file conflicts and version management issues restrict the development efficiency and quality of the project. These problems have become the key bottlenecks restricting the further development of low-code platforms.

[0024] In view of the above shortcomings, the present invention proposes a multi-person collaborative programming method based on modularization and collaborative optimization. The core idea of ​​the method is to change the working mode of the traditional project directory tree through modular task splitting. The present invention introduces a task designer that supports multi-canvas visual design, which divides complex projects into multiple subtasks, each of which is presented in an independent canvas. This canvas-based design method makes the boundaries between tasks more clear, laying the foundation for multi-person parallel development.

[0025] In addition, the present invention solves the problems of module migration and reuse in traditional directory trees through modular storage and identification mechanisms. Single or multiple subtasks can be saved independently as module files and managed through unique identifiers. This modular file format not only simplifies cross-project migration, but also provides technical support for the reuse of functions. When realizing multi-person collaborative development, the present invention ensures that the modules completed by each developer can be integrated into a unified project through module import and conflict detection mechanisms, and the logic and data reference relationship between modules can be accurately maintained.

[0026] Please refer to Figure 1 FIG. 1 is a flowchart of a method for multi-person collaborative programming in an embodiment of the present invention. The method for multi-person collaborative programming specifically includes the following steps:

[0027] S101: Provides a canvas task designer that supports visual design of multiple canvases, each canvas corresponding to a subtask.

[0028] It should be noted that the canvas task designer can be understood as a visual development environment that allows developers to design, manage and configure subtasks in independent canvases, so that there are clear logical and data boundaries between tasks. For example, the canvas task designer can be created based on the GraniStudio zero-code development platform. Figure 2 Schematic diagram of the interface of a canvas task designer in one embodiment of the present invention.

[0029] The canvas task designer is presented in a modular way. Each canvas is designed as an independent workspace, supporting operations such as dragging components, defining operators and data flows. Developers can intuitively draw the execution logic of tasks through the canvas. For example, connecting lines represent the data flow between tasks, and nodes identify the input and output relationship of tasks. In addition, the canvas task designer provides a wealth of interactive functions, including the configuration interface of task nodes, property display window, and real-time preview function, to ensure that developers can quickly understand and modify task logic.

[0030] The task management methods of traditional low-code platforms often lack flexibility. All tasks are concentrated in one workspace, and the dependencies between tasks are difficult to express intuitively. Especially when facing complex projects, the blurred boundaries between tasks can easily lead to logical conflicts and difficulties in version management. With the multi-canvas designer, each task can be isolated in an independent workspace. This structure not only simplifies the task development process, but also provides greater flexibility for collaboration between tasks.

[0031] S102: Save the subtasks designed in a single or multiple canvases as independent module files. Each module file can be developed by different developers.

[0032] The core of step S102 is to save the subtasks designed in a single or multiple canvases as independent module files, and different developers can be responsible for the development of these module files. This design is to solve the problems of unclear task boundaries, high file coupling and low efficiency of multi-person collaborative development in the traditional development model. By saving tasks in modular form and giving them independence, it not only simplifies the development process, but also provides technical support for multi-person parallel development.

[0033] In actual implementation, step S102 relies on a system architecture that supports modular storage. After the canvas task designer completes the subtask design, the canvas logic, configuration, and related data can be saved as independent module files through the built-in storage function. The module file adopts a unified standard format (such as XML, JSON, or a file format defined by a specific platform) to ensure the portability and compatibility of the module in different environments.

[0034] In an exemplary embodiment, the method further includes: creating a canvas display control, wherein the canvas display control is used to display attribute information of objects within the canvas, wherein the attribute information includes object name, input data name, output data name, input node, output node, whether configured, whether there is a breakpoint, whether locked, whether disabled, and node color used to characterize the data type.

[0035] The canvas display control is the core interactive unit in the canvas task designer. It displays the attribute information of the object to the user in a visual way. Each control represents a task object (such as a control algorithm module, a sensor data node, etc.), which may be a logical node, an operator, or a data interface. In the canvas display control, the basic properties of the object can be displayed, including the object name, the input and output data name, the input and output node identification, and the status information of the object (such as whether it has been configured, whether there is a breakpoint, whether it is locked or disabled). In addition, in order to enhance the understanding of data types, the canvas display control adopts a color coding mechanism, and different colors represent different data types, helping developers quickly identify and ensure the legitimacy of the connection.

[0036] The specific ways to achieve this function include: In the canvas designer, each control has a dynamically generated property display box, which lists the property information of the object in the form of a table or card. When the developer drags the control into the canvas, the system automatically generates a property display box corresponding to the control and updates its content in real time. For example, the identification of input nodes and output nodes can be represented by icons or arrows, and the node color is automatically assigned according to the data type. Developers can modify the property settings of the object by clicking the display box, or define the data flow between nodes by dragging the connection line.

[0037] In combination with the application scenario of industrial automation motion control, suppose that the developer is designing a motion control program for an industrial robot joint. In the canvas task designer, the "speed control module" can be added to the canvas as an object, and its display control shows the module name, input data (target speed), output data (actual speed), input node (target speed input terminal), and output node (feedback speed output terminal). In addition, the node color may be used to distinguish different data types, such as blue for control signals and green for feedback signals. When the developer connects the module with the "acceleration planning module", the display control will update the connection status in real time and prompt whether there is a data type mismatch or logic breakpoint.

[0038] The role of the canvas display control is to transform complex system logic into intuitive visual information. Through the clear display of object attribute information, developers can quickly understand the relationship between objects and avoid common design errors, such as node connection errors or data type mismatches. At the same time, status information (such as breakpoints or lock status) provides key debugging information at runtime to help developers identify and solve potential problems. In addition, the introduction of color coding simplifies the management of data types and significantly improves operational efficiency.

[0039] In an exemplary embodiment, the method further includes: creating operator objects corresponding to the subtasks in the canvas, configuring each operator object based on the attribute information displayed by the canvas display control, and setting data reference relationships and logical relationships between each operator object.

[0040] An operator object can be understood as a functional unit in the system, which may represent a computing node, a logic module, or an interface node. In industrial automation motion control, these operator objects can be speed control modules, path planning modules, position detection modules, etc. The canvas display control provides a complete view of the properties of each operator object, including the type and name of input and output data, node connection status, and logical configuration options. By configuring the properties of the operator object, developers can define its data reference relationship (such as data input source and output target) and logical relationship (such as execution order and conditional judgment).

[0041] When implementing this function, developers place operator objects into the canvas by dragging or adding them. Once the object is created, the system automatically generates the corresponding display control and displays the default attribute information of the operator. Developers can click the control to enter the attribute editing interface and modify the input and output data types, logical conditions, execution priority and other attributes of the operator. At the same time, developers can also connect the output nodes of operator objects to the input nodes of other operators by dragging lines to establish data reference relationships. In addition, the system will verify the legitimacy of these connections in real time, such as ensuring that the input and output data types are consistent and the connection relationship does not form a circular logic.

[0042] For example, in an industrial automation motion control scenario, suppose you need to design a path tracking control program for a robot arm. Developers can create the following operator objects in the canvas: "path planning module", "speed control module", and "position feedback module". By displaying controls, developers can configure the input path points and output target position data for the "path planning module"; connect its output to the input node of the "speed control module" to achieve path-to-speed mapping; and then connect the output of the "speed control module" to the "position feedback module" to achieve real-time position monitoring. The logical relationship of the entire process is intuitively displayed on the canvas through these connecting lines, and developers can understand and adjust the control process at a glance.

[0043] S103: The developed module file is persistently stored locally, and a module ID is created for the module file.

[0044] The module file is a complete record of the subtask design, including the attribute information of the operator object, data reference relationships, logical execution order, and canvas resource configuration. Persistent storage refers to saving these module files to local storage media, such as hard disks, cloud storage, or other storage devices that support file systems. The core purpose of persistence is to ensure that module files can be saved across sessions while maintaining their integrity and consistency in different environments. To achieve this, module files usually use structured file formats such as JSON, XML, or proprietary formats to ensure that the file content is highly compatible during storage, reading, and parsing.

[0045] The creation of a module ID can assign a unique identifier to each module file to identify the module's properties and functions. The module ID can be generated in a variety of ways, such as a dynamic ID based on a timestamp, a UUID (universally unique identifier), a file name hash value, or a custom naming rule. In scenarios of multi-person collaboration and cross-project development, the uniqueness of the module ID ensures that conflicts between module files are minimized, making it easier to track, manage, and version modules.

[0046] For example, in the industrial automation motion control scenario, suppose the development team designs a control system for an automated production line, which includes a "raw material conveying control module", a "processing equipment motion control module" and a "finished product inspection module". The developers complete the canvas design of each module and save these modules as independent module files. Taking the "processing equipment motion control module" as an example, the module file records the operator properties of the equipment motion control (such as speed, acceleration configuration), data reference relationships (such as the connection between position sensor feedback and control logic), and logical order (such as execution trajectory planning takes precedence over speed control). After the design is completed, the system stores the module file in JSON format and assigns a module ID, such as "MOD-20231120-001", indicating the category and creation time of the module. This module file can be imported into other projects at any time, or modified and reused in subsequent projects.

[0047] Taking the appearance defect detection of products on the production line as an example, the detection system can be divided into multiple subtasks in a modular way and completed independently by different developers. The canvas task designer provides a development environment so that these subtasks can be saved independently as module files and finally integrated into a complete intelligent detection system.

[0048] The goal of this intelligent inspection system is to identify surface defects of products through visual inspection and complete product conveying and classification through motion control. Developers first use the canvas task designer to divide the task into multiple modules, including "conveyor belt motion control module", "visual image acquisition module", "image preprocessing and inspection module" and "result classification module". Each module is designed and developed by different developers.

[0049] The "conveyor belt motion control module" can be designed by motion control engineers, and its main task is to control the start, stop and speed adjustment of the conveyor belt to ensure that each product stays accurately in the inspection area; the "visual image acquisition module" can be developed by visual engineers, and its function is to capture images in real time through industrial cameras and pass image data to subsequent modules; the "image preprocessing and detection module" can be completed by algorithm engineers, mainly through image denoising, edge detection and target classification operations to achieve defect detection functions; finally, the "result classification module" can be the responsibility of system integration engineers, who control the movement of the robotic arm according to the inspection results, send qualified products to the designated area, and remove unqualified products.

[0050] After development, each module can be persisted and saved as an independent file (such as ".mod" format), and uniquely identified by the module ID. The module file not only saves the core logic of each module, but also records the data input and output relationship and calling sequence between modules. This modular design not only simplifies the division of tasks, but also supports cross-project reuse of modules.

[0051] In an exemplary embodiment, the method further includes: recording each operator object and its attributes and operator ID, and recording the sequence and reference relationship between operators; persisting the operator object file and canvas resource file locally, and saving them as module files that can be imported into the engineering project.

[0052] Record operator objects and their attributes, unique identifiers (operator IDs), and the order and reference relationships between operators, and store this information persistently as module files. The purpose of this process is to provide clear unique identifiers and data relationship support for operator objects, thereby achieving modular management in system design and providing technical support for the import, reuse and integration of subsequent engineering projects. This design is particularly suitable for the field of industrial automation motion control, supporting the efficient development and flexible expansion of complex control systems.

[0053] During the implementation process, the attributes of the operator object include its name, the type of input and output data, node connection information, logical priority, and status information (such as whether it is enabled or configured). Each operator object is assigned a unique operator ID to identify the uniqueness of the operator in the entire system. This ID generation method can be automatically assigned by the system (such as UUID) or user-defined. Recording the sequence and reference relationship between operators ensures the accuracy of data flow and execution logic. For example, the output data of an operator needs to be used as the input data of another operator. This reference relationship needs to be clearly marked and recorded.

[0054] In a specific implementation, after the user completes the design and configuration of the operator object in the canvas task designer, the system will extract the attribute information and logical relationship of each operator and save it as structured data (such as JSON or XML format). At the same time, the resource information of the canvas itself (including the layout of the operator, the coordinates of the connecting lines, etc.) will also be stored synchronously. These data will eventually be packaged into module files (such as files in a specific format, such as ".mod") and persisted to the local storage device. This standardized storage method of module files ensures the consistency, integrity and portability of operator data.

[0055] S104: Import each module file into a unified project engineering, edit the data reference relationship and execution logic between each module file, and complete the collaborative programming of the project engineering.

[0056] By importing multiple independent module files into a unified project and editing the data reference relationship and execution logic between the module files, the collaborative programming of the entire project is completed. This process integrates the scattered subtasks or functional modules and builds a complete and coordinated system through reasonable logical relationships and data flow definitions.

[0057] When implementing step S104, you can rely on a system platform that supports module import and integration (such as GraniStudio zero-code development platform). As an independently designed functional unit, the module file can contain content such as input and output interfaces, internal logic and status information. During the import process, the platform will parse the module file, read its data reference relationship and logical configuration, and map it to the canvas of the project. In the canvas, the module file is usually displayed in the form of a visual node, and the developer can adjust the relationship between the modules by dragging, connecting and configuring. For example, the input and output relationship between modules is defined by data connection lines, or the execution priority and triggering rules of the module are set by logical conditions.

[0058] Combined with the actual scenario of industrial automation motion control, it is assumed that a control system for an intelligent production line needs to be designed, involving multiple functional modules, including "conveyor belt control module", "robotic arm motion module" and "quality inspection module". Each module has been completed in the early development and saved as an independent module file. In step S104, the developer first imports these module files into a unified project project. After importing, the system will display the properties, interfaces and logic of the module in the form of nodes in the canvas. For example, the "conveyor belt control module" contains an input interface (start signal, speed setting value) and an output interface (actual speed feedback); the "robotic arm motion module" contains a position input interface and a control output interface. Subsequently, the developer can use the canvas editing tool to connect the output speed feedback of the "conveyor belt control module" to the position input of the "robotic arm motion module" to achieve the coordinated operation of the two. At the same time, the logical relationship is set so that the "quality inspection module" automatically starts after the robotic arm completes the operation to complete the product quality monitoring.

[0059] In an exemplary embodiment, each module file is imported into a unified project project, including: detecting whether there is a conflict between the module ID of the imported module file and the module ID of the existing module file in the project project; if there is a conflict, modifying the module ID of the imported module file or replacing the existing module file with the conflict with the imported module file.

[0060] The module ID is an important identifier of the module file, which is used to uniquely mark each module file and its corresponding functions, data interfaces, and logical configurations. In multi-person collaborative development, different developers may assign duplicate IDs to the same type of module files, or in cross-project integration, module IDs in different projects may be duplicated. If such conflicts are not detected and resolved, the logical relationship of the modules in the system will be disordered, and even serious errors will occur during runtime.

[0061] When a module file is imported into a project, the system will scan all existing module IDs in the current project and compare them with the ID of the imported module. If a duplicate ID is detected, the system will trigger the conflict handling mechanism; at this time, the system will prompt the user to choose to overwrite the existing module or create a new module.

[0062] If the user chooses to overwrite, the imported module will replace the existing module, ensuring that the latest version of the function module is used in the project. This method is suitable for situations where existing function modules need to be updated, ensuring the latest and consistency of the system.

[0063] If the user chooses to create a new module, the system will generate a new unique ID for the imported module to avoid duplication with the existing module ID. This process can be achieved by automatically adding prefixes, suffixes or serial numbers, such as changing the conflicting module ID "MOD-001" to "MOD-001-A" or "MOD-001-1". This method is suitable for situations where you need to reuse existing modules but do not want to overwrite the original functions, which enhances the flexibility of the system and the reusability of the modules.

[0064] In an exemplary embodiment, the method further includes: detecting whether the operator ID of the operator object in the imported module file conflicts with the operator ID of the operator object already in the project; if there is a conflict, modifying the operator ID of the operator object in the imported module file or replacing the conflicting existing operator object with the imported operator object. The method of modifying the operator ID of the operator object in the imported module file includes: adding a prefix, suffix, sequence number or character to the original operator ID, or rebuilding the ID.

[0065] The operator ID is the unique identifier of each operator object, which is used to indicate its uniqueness and data logic position in the project. The core goal of this mechanism is to maintain the independence and consistency of operator objects in the project and ensure that the data flow and logical relationship between operator objects are accurate. Especially in the field of industrial automation motion control, complex task logic and data flow management have particularly strict requirements on the consistency of operator IDs.

[0066] When a module file is imported into a project, the system will automatically scan all operator object IDs in the imported module and compare them with the IDs of the existing operator objects in the project. If a conflict is found, the system will prompt the user to choose to overwrite the existing operator object or create a new one.

[0067] If you choose to create a new operator object, the system will generate a new unique ID for the conflicting operator object and replace the old ID. This new operator ID generation mechanism can be based on a variety of rules, such as:

[0068] Add a prefix or suffix, append a timestamp, module name, or auto-increment number to the original ID (such as changing "Node-001" to "Node-001-ModA"). Generate a new ID, using UUID (universally unique identifier) ​​or generate a new independent ID based on module and operator features. Recursive detection and update, if the newly generated ID may still conflict with the existing ID, the system will continue to generate new IDs until uniqueness is ensured.

[0069] In summary, the method for multi-person collaborative programming provided by the present invention divides the entire project into multiple independent subtasks through a canvas task designer. The subtasks are saved in the form of module files and can be independently developed by different developers. The persistent storage of module files and the creation of module IDs ensure the independence and uniqueness of the modules, support cross-project reuse and version management, and reduce the cost of repeated design.

[0070] Please refer to Figure 3 As shown, based on the same inventive concept as the aforementioned multi-person collaborative programming method, the present invention provides a multi-person collaborative programming system 300, which includes: a canvas unit 301, a module unit 302, a persistence unit 303 and an import unit 304.

[0071] The canvas unit 301 is used to provide a canvas task designer that supports multiple canvas visualization designs, each canvas corresponding to a subtask. The module unit 302 is used to save the subtasks designed in a single or multiple canvases as independent module files, and each module file can be developed by different developers. The persistence unit 303 is used to store the developed module files persistently locally and create a module ID for the module file. The import unit 304 is used to import each module file into a unified project engineering, edit the data reference relationship and execution logic between each module file, and complete the collaborative programming of the project engineering.

[0072] Please refer to Figure 4 As shown, an embodiment of the present invention further provides an electronic device 400, which includes at least one processor 401, a memory 402 (such as a non-volatile memory), a memory 403, and a communication interface 404, and the at least one processor 401, the memory 402, the memory 403, and the communication interface 404 are connected together via a bus 405. At least one processor 401 is used to call at least one program instruction stored or encoded in the memory 402, so that the at least one processor 401 performs various operations and functions of the multi-person collaborative programming method described in various embodiments of this specification.

[0073] In an embodiment of the present specification, the electronic device 400 may include, but is not limited to, a personal computer, a server computer, a workstation, a desktop computer, a laptop computer, a notebook computer, a mobile electronic device, a smart phone, a tablet computer, a cellular phone, a personal digital assistant (PDA), a handheld device, a messaging device, a wearable electronic device, a consumer electronic device, and the like.

[0074] An embodiment of the present invention further provides a computer-readable medium carrying computer execution instructions, which, when executed by a processor, can be used to implement various operations and functions of the multi-person collaborative programming method described in various embodiments of this specification.

[0075] The computer-readable medium in the present invention can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, a system, device or component of electricity, magnetism, light, electromagnetic, infrared, or semiconductor, or any combination of the above. More specific examples of computer-readable storage media can include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present invention, a computer-readable storage medium can be any tangible medium containing or storing a program, which can be used by an instruction execution system, device or device or used in combination with it.

[0076] In the present invention, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, which carries a computer-readable program code. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which may send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, device, or device. The program code contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, optical cable, RF, etc., or any suitable combination of the above.

[0077] Those skilled in the art will appreciate that embodiments of the present invention may be provided as methods, systems, or computer program products. Therefore, the present invention may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0078] The present invention is described with reference to flowcharts and / or block diagrams of methods, apparatuses, systems, and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as a combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the process in the flowchart. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0079] It will be apparent to those skilled in the art that the invention is not limited to the details of the exemplary embodiments described above and that the invention can be implemented in other specific forms without departing from the spirit or essential features of the invention. Therefore, the embodiments should be considered exemplary and non-limiting in all respects, and the scope of the invention is defined by the appended claims rather than the foregoing description, and it is intended that all variations falling within the meaning and scope of the equivalent elements of the claims be included in the invention. Any reference numeral in a claim should not be considered as limiting the claim to which it relates.

[0080] In addition, it should be understood that although the present specification is described according to implementation modes, not every implementation mode contains only one independent technical solution. This description of the specification is only for the sake of clarity. Those skilled in the art should regard the specification as a whole. The technical solutions in each embodiment may also be appropriately combined to form other implementation modes that can be understood by those skilled in the art.

Claims

1. A method for multi-person collaborative programming, characterized in that: include: Provides a canvas task designer that supports visual design of multiple canvases, each canvas corresponding to a subtask; Save the subtasks designed in a single or multiple canvases as independent module files, each of which can be developed by different developers; The developed module files are persistently stored locally and a module ID is created for the module files; Import each module file into a unified project, edit the data reference relationship and execution logic between each module file, and complete the collaborative programming of the project.

2. The method for multi-person collaborative programming according to claim 1, characterized in that: The method further comprises: Create a canvas display control, which is used to display attribute information of objects in the canvas, including object name, input data name, output data name, input node, output node, whether configured, whether there is a breakpoint, whether locked, whether disabled, and node color used to characterize the data type.

3. The method for multi-person collaborative programming according to claim 2, characterized in that: The method further comprises: Create operator objects corresponding to the subtasks in the canvas, configure each operator object based on the attribute information displayed by the canvas display control, and set the data reference relationship and logical relationship between each operator object.

4. The method for multi-person collaborative programming according to claim 3, characterized in that: The method further comprises: Record each operator object and its attributes and operator ID, and record the sequence and reference relationship between operators; Persist the operator object file and canvas resource file locally and save them as module files that can be imported into the project.

5. The method for multi-person collaborative programming according to claim 4, characterized in that: Import each module file into a unified project, including: Check whether the module ID of the imported module file conflicts with the module file already in the project; If there is a conflict, the module ID of the imported module file is modified or the existing module file with the conflict is replaced with the imported module file.

6. The method for multi-person collaborative programming according to claim 4, characterized in that: The method further comprises: Check whether the operator ID of the operator object in the imported module file conflicts with the operator ID of the operator object already in the project; If there is a conflict, the operator ID of the operator object in the imported module file is modified or the existing operator object with a conflict is replaced with the imported operator object.

7. The method for multi-person collaborative programming according to claim 6, characterized in that: Modify the operator ID of the operator object in the imported module file, including: Add a prefix, suffix, sequence number, or character to the original operator ID, or rebuild the ID.

8. A multi-person collaborative programming system, characterized in that: include: Canvas unit, used to provide a canvas task designer that supports multiple canvas visual design, each canvas corresponding to a subtask; Module unit, used to save subtasks designed in a single or multiple canvases as independent module files. Each module file can be developed by different developers. The persistence unit is used to store the developed module files locally and create a module ID for the module files. The import unit is used to import various module files into a unified project engineering, edit the data reference relationship and execution logic between various module files, and complete the collaborative programming of the project engineering.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the program, the method for multi-person collaborative programming according to any one of claims 1 to 7 is implemented.

10. A computer-readable medium, characterized in that The computer-readable medium carries computer-executable instructions, and when the computer-executable instructions are executed by a processor, they are used to implement the multi-person collaborative programming method according to any one of claims 1 to 7.

Images