Method and apparatus for application development, and device and product

Abstract

The present disclosure relates to and provides a method and apparatus for application development, and a computing device, a computer-readable storage medium and a computer program product. The method comprises: on the basis of a visual application workflow orchestrated on a zero or low code platform, generating a first domain-specific language file associated with the zero or low code platform; on the basis of the first domain-specific language file, generating a first executable code of an application; and in an integrated development environment, using the first executable code for the development of the application.

Description

Method, device, equipment and product for application development TECHNICAL FIELD

[0001] The present disclosure relates to the technical field of computer, and more particularly, to a method, device, computing equipment, computer readable storage medium and computer program product for application development. BACKGROUND

[0002] Currently, when developing an application related to a generative model, it is often necessary to arrange the nodes and edges encapsulated by some mainstream development framework into a graph to describe the business logic and the calling and dependency relationship between nodes.

[0003] Zero or low code platform is an application development tool that allows non-developers, even users without any programming background, to quickly build an application through a visual interface and pre-built modules without or with a small amount of code writing, such as dragging and dropping components, configuring parameters, etc. In addition, more professional developers can also use the relevant zero or low code platform to quickly build a Demo application for proof of concept (POC) after being familiar with the framework to a certain extent.

[0004] Domain-specific language (DSL) is a language designed for a specific domain, which focuses on solving specific problems in that domain and provides syntax and semantics closely related to that domain. DSL files usually contain code, declarations, rules or configurations written in the DSL. These files can be processed by specific tools, compilers or interpreters to generate code, perform calculations, verify rules or configure systems, etc.

[0005] SUMMARY

[0006] The present disclosure provides a method, device, computing equipment, computer readable storage medium and computer program product for application development, which can support developers to export a zero or low code platform as a full code project for in-depth full code development by converting the visual workflow of the zero or low code platform into a domain-specific language file and then converting the domain-specific language file into executable code after the workflow arrangement.

[0007] According to a first aspect of the present disclosure, a method for application development is provided, comprising: generating a first domain-specific language file associated with a zero or low code platform based on a visual workflow of an application arranged in the zero or low code platform; generating a first executable code of the application based on the first domain-specific language file; and using the first executable code in an integrated development environment for development of the application.

[0008] According to a second aspect of the disclosure, there is provided an apparatus for application development, comprising: a first domain specific language file generation unit configured to generate a first domain specific language file associated with a zero-code platform based on a workflow of a visualized application orchestrated on the zero-code platform; a first executable code generation unit configured to generate a first executable code of the application based on the first domain specific language file; and an application development unit configured to use the first executable code in an integrated development environment for development of the application.

[0009] According to a third aspect of the disclosure, there is provided a computing device comprising: at least one processing unit; at least one memory coupled to the at least one processing unit and storing instructions for execution by said at least one processing unit, which when executed by said at least one processing unit, cause the computing device to perform the method as claimed in the first aspect of the disclosure.

[0010] According to a fourth aspect of the disclosure, there is provided a non-transitory computer storage medium comprising machine executable instructions, which when executed by a device, cause the device to perform the method as claimed in the first aspect of the disclosure.

[0011] According to a fifth aspect of the disclosure, there is provided a computer program product comprising machine executable instructions, which when executed by a device, cause the device to perform the method as claimed in the first aspect of the disclosure.

[0012] It is to be understood that the Summary is not intended to identify key or essential features of embodiments of the disclosure, nor is it intended to be used to limit the scope of the disclosure. Other features, details, and advantages of the disclosure will become BRIEF DESCRIPTION OF DRAWINGS

[0013] The above and other objects, features and advantages of embodiments of the disclosure will become more apparent from the following detailed description when taken in conjunction with the accompanying drawings, in which:

[0014] FIG. 1 shows a schematic diagram of an example environment in which embodiments of the disclosure can be implemented;

[0015] FIG. 2 shows a schematic flowchart of a method of application development according to embodiments of the disclosure;

[0016] FIG. 3 shows a schematic flowchart of generating a full-code project from a visualized graphical representation according to embodiments of the disclosure;

[0017] FIG. 4 shows a schematic flowchart of nodes of low zero-code platform application full-code development according to embodiments of the disclosure;

[0018] FIG. 5 shows a block diagram of an apparatus for application development according to an embodiment of the present disclosure; and

[0019] FIG. 6 shows a block diagram of an electronic device according to an embodiment of the present disclosure.

[0020] In all the drawings, the same or similar reference numerals indicate the same or similar elements. DETAILED DESCRIPTION

[0021] Embodiments of the present disclosure will be described in detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure are shown in the drawings, it is understood that the present disclosure can be embodied in various forms and should not be interpreted as being limited to the embodiments set forth herein, but rather, these embodiments are provided so that the present disclosure can be more thoroughly and completely understood. It is understood that the drawings of the present disclosure and the embodiments are only for exemplary purposes and are not intended to limit the scope of protection of the present disclosure.

[0022] In the description of embodiments of the present disclosure, the term "comprising" and its conjugates should be understood to be open-ended, i.e., "including but not limited to". The term "based on" should be understood as "based at least in part on". The term "one embodiment" or "an embodiment" should be understood as "at least one embodiment". The terms "a first", "a second", etc. can refer to different or same objects, unless explicitly stated otherwise. Other explicit and implicit definitions can also be included below.

[0023] As described above, the zero-code platform can allow more professional developers to quickly build a demo for proof of concept. However, after the professional developers perform the proof of concept, they often need to continue to develop more complex business logic and more powerful systems by coding in the integrated development environment (IDE), while the zero-code platform cannot convert the demo built by it into real executable code. Therefore, the professional developers can only start coding from scratch to build the application, which seriously affects the development efficiency.

[0024] In addition, although the zero-code platform allows non-developers to build applications very conveniently, when the non-developers have more expansion needs, the zero-code platform can not support the implementation of new needs, so that more professional developers need to access to develop corresponding custom nodes by coding in the IDE to improve the complexity upper limit of the application that can be built. At this time, these more professional developers often need to learn the domain-specific language defined by the zero-code platform to enter the development, which is very inefficient.

[0025] To address or mitigate the above-mentioned problems and / or other potential problems, embodiments of the present disclosure propose a method for application development. The method can support developers to export a workflow developed using a zero-code platform as a full-code project for in-depth full-code development by converting a visualized workflow of the zero-code platform into a domain-specific language file and then converting the domain-specific language file into executable code.

[0026] The basic principles and implementation manners of the present disclosure are explained below with reference to the accompanying drawings. It should be understood that the exemplary embodiments are only given to enable those skilled in the art to better understand and implement the embodiments of the present disclosure, and do not limit the scope of the present disclosure in any way.

[0027] FIG. 1 shows a schematic diagram of an environment 100 capable of implementing multiple embodiments of the present disclosure. As shown in FIG. 1, the environment 100 can include a zero-code platform 110 and an integrated development environment (IDE) 140. The zero-code platform 110 can be oriented to professional and non-professional developers for visualized application development, while the IDE 140 can be oriented to professional developers for full-code application development. As shown in FIG. 1, the zero-code platform 110 can include a front-end interface 120 and a back-end environment 130. The front-end interface 120 is displayed on the terminal interface used by the user to develop the application and is directly visible to the user, while the back-end environment 130 is usually deployed in a server or cloud environment and is not visible to the user.

[0028] The front-end interface 120 is responsible for showing the interface of the zero-code platform to the user, including the layout and style of various graphics, charts, forms, buttons, and other elements, and processing the input and operation of the user, such as clicking, dragging, zooming, etc., and feeding back the corresponding results or changes to the user in a timely manner. As shown in FIG. 1, the front-end interface 120 can include a canvas 121. The workflow of an application developed using the zero-code platform 110 can be represented in the canvas 121 in a visualized graphical representation, such as a topology graph. It should be understood that the present disclosure does not limit the form of the visualized graphical representation of the workflow of the application. In some embodiments, the user can perform zoom-in, zoom-out, drag, and other operations on the canvas 121 to facilitate viewing of the information of the visualized graphical representation of the workflow in the canvas 121.

[0029] The backend environment 130 is mainly responsible for processing business logic, data storage, system integration and other tasks, and processes data to meet the needs of the front-end interface 120 by receiving data requests sent by the front-end interface 120. As shown in FIG. 1, the backend environment 130 can include a domain-specific language file (DSL) 131 and a model framework code 132. The model framework code 132 is developed by the developer of the zero-code platform, and the model framework code 132 is converted into the DSL 131 according to a custom protocol. Then, based on the DSL 131, the visual graphical representation of the workflow in the canvas 121 can be easily generated.

[0030] As shown in FIG. 1, the IDE 140 can include executable code 141. The IDE 140 usually has a built-in compiler or can call an external compiler to compile the executable code 141 into an executable file. The IDE 140 can also include debugging, running, deployment and other functions to enable developers to easily create, test and manage executable code 141. In the present disclosure, the visual graphical representation of the workflow in the canvas 121 and the executable code 141 in the IDE 140 are converted to each other to support users of the zero-code platform to carry out more in-depth development. The process of implementing the application development method of the present disclosure is further described below with reference to FIG. 2.

[0031] FIG. 2 shows a schematic flowchart of a method 200 of application development according to an embodiment of the present disclosure. In some embodiments, the method 200 can be implemented by a functional plug-in in the zero-code platform 110, for example, as shown in FIG. 1. It should be understood that the method 200 can also include additional actions not shown and / or can omit the actions shown, and the scope of the present disclosure is not limited in this respect.

[0032] As shown in FIG. 2, at block 210, the method 200 can include generating a first domain-specific language file associated with the zero-code platform based on a workflow of a visualized application orchestrated in the zero-code platform. In some embodiments, a user can first adjust the visual graphical representation of the workflow of the application in the zero-code platform by drag-and-drop or the like to complete the preliminary development of the application. The visual graphical representation of the workflow can include node information and edge information of the workflow.

[0033] A node can represent any entity or object (e.g., class, function, variable, module, component, etc.) that performs a number of logics, which can include basic attributes such as node name, node type, node input parameter declaration, and node output parameter declaration. In the canvas 121, a node can be represented in the form of a functional block diagram. In the preliminary development stage of an application, a user can select a node module corresponding to a specific function needed and add it to the canvas 121, and then fill in the attributes of the node module, such as the name, type, input / output parameter type, etc. of the node module. For example, a user adds a node module for sorting in the canvas 121, and then the user can specify the sorting rule (e.g., ascending or descending) and the output result type (e.g., array or string) in the node module.

[0034] An edge is a data structure (e.g., adjacency matrix, adjacency list, etc.) connecting two nodes, which represents the relationship or interaction of data flow and execution order between the nodes, and can include basic attributes such as edge type, start node name, and end node name. In the canvas 121, an edge can be represented in the form of a directed connection line or an undirected connection line. In the preliminary development stage of an application, a user can add connection lines between selected node modules to indicate the execution order and logic (e.g., sequential, parallel, or branching) of the node modules.

[0035] In some embodiments, the functional plug-in of the zero-code platform can obtain the node information and edge information of the workflow of the application, and then generate a first domain-specific language file based on the obtained node information and edge information. An exemplary first domain-specific language file can be represented in the following form:

[0036] The attributes of the node are explained as follows:

[0037] Table 1

[0038] The attributes of the edge are explained as follows:

[0039] Table 2

[0040] At block 220, the method 200 can include generating a first executable code of the application based on the first domain-specific language file. As shown above, in the first domain-specific language file, the node information and edge information of the workflow of the application have been structured and recorded. In some embodiments, the functional plug-in of the zero-code platform can obtain the node information and edge information from the first domain-specific language file, and then generate the first executable code based on the obtained node information and edge information.

[0041] At block 230, the method 200 can include using the first executable code in an integrated development environment for development of the application. Thus, a user can use the executable code converted from the visual graphical representation of the workflow of the application by the DSL language to continue the full-code deep development from the zero-low code platform to the IDE without being limited by the functions and the number of the node modules in the zero-low code platform.

[0042] FIG. 3 illustrates a schematic flowchart 300 of generating a full-code project from a visual graphical representation according to an embodiment of the present disclosure. As shown in FIG. 3, in a zero-low code platform 310, the conversion from a front-end topology canvas 311 to a drawing topology DSL 312 can be implemented by a function plug-in, for example. The function plug-in can identify the node information and the edge information of the workflow of the application contained in the front-end topology canvas 311 and record the node information and the edge information in a structured manner through a self-defined conversion protocol to generate the drawing topology DSL 312. Then, the function plug-in can extract the node information and the edge information of the workflow from the drawing topology DSL 312 to generate a model framework code 313 executable in an IDE.

[0043] With the executable model framework code 313, a user can choose to import it into a local IDE 320 in the form of a compressed package for deep development of a full-code project 321 or directly upload it to a code repository 331 of a cloud IDE 330 for deep development of a full-code project 332. The local IDE 320 refers to an integrated development environment installed on a local computer, which integrates multiple functions such as code writing, debugging, compiling, running, etc., to provide a complete development platform for developers. The cloud IDE 330 is a cloud tool that does not require a local environment and can access a cloud development environment 333 through a browser to realize the functions of code writing, compiling and debugging, running preview, accessing a code repository, command line execution, etc. It allows developers to develop software in the cloud without the need to install and configure a complex development environment on a local computer.

[0044] In order to enable professional developers to continue the development process of the application without facing the learning cost of the specific DSL of the zero-low code platform when non-professional developers using the zero-low code platform face the inability to support new requirements, in some embodiments, a second domain-specific language file can be generated based on the second executable code associated with the custom node. Then, a visual graphical representation of the custom node is generated based on the second domain-specific language file. By adding the visual graphical representation of the custom node to the zero-low code platform, a user can easily arrange the workflow of the application to continue the development process of the application. The process of implementing the method of deep application development based on the zero-low code platform according to the present disclosure is further described below with reference to FIG. 4.

[0045] FIG. 4 shows a schematic flowchart 400 of a full-code developed node applied to a low zero-code platform, according to an embodiment of the present disclosure. As shown in FIG. 4, in some embodiments, a user can develop one or more model framework code development nodes 402 for a low zero-code platform under a cloud development environment 403 in a cloud IDE 401, which can be applied to the workflow of an application preliminarily developed on a low zero-code platform and implement specific functional requirements. Then, the user can publish the developed model framework code development nodes 402. At this time, the low zero-code platform 406 cannot directly use the nodes because the low zero-code platform 406 uses a front-end topology canvas for visual development, and the full-code developed model framework code development nodes 402 cannot be directly converted into a visual graphical representation. In some embodiments, at step 404, the executable code of the model framework code development nodes 402 can first be converted into a structured DSL file to record the key node information and edge information constituting the workflow therein. Then, based on the structured DSL file, nodes 405 usable by the canvas in the low zero-code platform 406 can be generated. At this time, at step 407, the user of the low zero-code platform 406 can select and configure the nodes 405 in the front-end topology canvas by drag-and-drop and the like to implement the in-depth development of the application as in the preliminary development stage.

[0046] In some embodiments, based on the third executable code associated with the custom node, a software development kit (SDK) can also be generated, and then by depending on and consuming the SDK in the first executable code, the user can also be able to perform the in-depth development of the application. The SDK is a collection of software tools, library files, documents, and sample codes, which provides developers with the interfaces, tools, and resources required to develop specific software applications. Depending on and consuming the SDK refers to the process of downloading, importing, and using the functions and interfaces provided by the SDK to build an application during the development process of a developer.

[0047] As shown in FIG. 4, instead of converting the full-code developed nodes into visual nodes in the low zero-code platform 406, professional developers can generate corresponding SDKs therefrom. The user who has completed the preliminary development stage of the application using the low zero-code platform 406 can convert the visual workflow into an executable full-code project 409 in the manner shown in method 200, and then depend on and consume the above-mentioned SDKs in the full-code project 409, and can also complete the in-depth development of the application.

[0048] The exemplary embodiments of the present disclosure are described above with reference to FIGS. 1-4. Compared with the existing application development method, the application development scheme of the present disclosure can support the developer to export the workflow arranged using the zero-code platform into a full-code project for deep full-code development by converting the visual workflow of the zero-code platform into a domain-specific language file and then converting the domain-specific language file into executable code.

[0049] FIG. 5 shows a schematic block diagram of an apparatus 500 for application development according to an embodiment of the present disclosure. As shown in FIG. 5, the apparatus 500 includes a first domain-specific language file generation unit 510, a first executable code generation unit 520, and an application development unit 530.

[0050] In some embodiments, the first domain-specific language file generation unit 510 is configured to generate a first domain-specific language file associated with the zero-code platform based on a workflow of a visualized application arranged on the zero-code platform; the first executable code generation unit 520 is configured to generate a first executable code of the application based on the first domain-specific language file; and the application development unit 530 is configured to use the first executable code in an integrated development environment for development of the application.

[0051] In some embodiments, the first domain-specific language file generation unit 510 is further configured to obtain node information and edge information of the workflow of the application; and generate the first domain-specific language file based on the node information and the edge information.

[0052] In some embodiments, the first executable code generation unit 520 is further configured to obtain the node information and the edge information from the first domain-specific language file; and generate the first executable code based on the node information and the edge information.

[0053] In some embodiments, the apparatus 500 further includes a workflow arrangement unit configured to generate a second domain-specific language file based on a second executable code associated with a custom node; generate a visual graphical representation of the custom node based on the second domain-specific language file; and arrange a workflow of the application by adding the visual graphical representation of the custom node to the zero-code platform.

[0054] In some embodiments, the workflow arrangement unit is further configured to generate a software development kit based on a third executable code associated with the custom node; and arrange the workflow of the application by depending on and consuming the software development kit in the first executable code.

[0055] In some embodiments, the apparatus 500 further includes an application preliminary development unit configured to preliminarily develop the application by adjusting the visual graphical representation of the workflow.

[0056] In some embodiments, the application comprises a generative model application.

[0057] It should be noted that more actions or steps shown in FIGS. 1-4 can be implemented by the apparatus 500 shown in FIG. 5. For example, the apparatus 500 can comprise more modules or units to implement the actions or steps described above, or some units or modules shown in FIG. 5 can be further configured to implement the actions or steps described above. No further elaboration is made here.

[0058] FIG. 6 shows a schematic block diagram of an example device 600 that can be used to implement embodiments of the present disclosure. As shown, the device 600 includes a computing unit 601 that can perform various appropriate actions and processes according to computer program instructions stored in a read-only memory (ROM) 602 or loaded into a random access memory (RAM) 603 from a storage unit 606. Various programs and data required for operation of the device 600 can also be stored in the RAM 603. The computing unit 601, the ROM 602, and the RAM 603 are connected to each other by a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0059] Various components in the device 600 are connected to the I / O interface 605, including: an input unit 606, such as a keyboard, a mouse, etc.; an output unit 607, such as various types of displays, a speaker, etc.; a storage unit 608, such as a magnetic disk, an optical disk, etc.; and a communication unit 609, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 609 allows the device 600 to exchange information / data with other devices through a computer network, such as the Internet, and / or various telecommunication networks.

[0060] The computing unit 601 can be various general and / or special purpose processing components with processing and computing capabilities. Some examples of the computing unit 601 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various specialized artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 601 performs various methods and processes described above, such as the method 200. For example, in some embodiments, the method 200 can be implemented as a computer software program tangibly embodied in a machine-readable medium, such as the storage unit 608. In some embodiments, part or all of the computer program can be loaded and / or installed onto the device 600 via the ROM 602 and / or the communication unit 609. When the computer program is loaded onto the RAM 603 and executed by the computing unit 601, one or more steps of the method 200 described above can be performed. Alternatively, in other embodiments, the computing unit 601 can be configured to perform the method 200 by any other suitable means, such as by means of firmware.

[0061] In some embodiments, the methods and processes described above can be implemented as computer program products. Computer program products can include computer readable storage media having computer readable program instructions thereon for performing various aspects of the present disclosure.

[0062] Computer readable storage media can be, for example, but not limited to, electronic, magnetic, optical, electromagnetic, infrared, semiconductor system, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of computer readable storage media include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or punched tape, a magnetically encoded device such as tape, an optically encoded device such as a compact disc (CD) or DVD, and / or any suitable combination of the foregoing. Computer readable program instructions can be downloaded to or from computer readable storage media 608. The computer readable program instructions can be downloaded to the device 600 from the computer readable storage media 608 and / or executed by processing circuitry 601. The computer readable program instructions can also be downloaded to or from other computer readable media for execution by one or more processors of one or more machines.

[0063] Computer readable program instructions described herein can be downloaded to respective computing / processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and / or a wireless network. The network can comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and / or edge servers. A network adapter card or network interface in each computing / processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing / processing device.

[0064] Computer readable program instructions for carrying out operations of the present disclosure can be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language and conventional procedural programming languages. The computer readable program instructions can execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer can be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection can be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate array (FPGA), or programmable logic array (PLA) can execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present disclosure.

[0065] These computer readable program instructions can be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in the flowchart and / or block diagram block or blocks. These computer readable program instructions can also be stored in a computer readable storage medium that can include a non-transitory computer readable storage medium that can direct a computer, a programmable data processing apparatus, and / or other devices to function in a particular manner, such that the computer readable storage medium having instructions for causing an apparatus to implement one or more functions / acts specified in the flowchart and / or block diagram block or blocks is provided. The instructions of the computer

[0066] The computer readable program instructions can also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus or other device to produce a computer implemented process such that the instructions which execute on the computer, other programmable data processing apparatus, or other device implement the functions / acts specified in the flowchart and / or block diagram block or blocks.

[0067] The flow diagrams and the block diagrams in the drawings are presented to illustrate the architecture, functionality, and operation of possible implementations of devices, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flow diagrams and the block diagrams can represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logic functions. In some alternative implementations, the functions noted in the blocks can occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks can sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and / or flow diagrams, and combinations thereof, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and

[0068] Embodiments of the present disclosure have been described above, and the description is intended to be illustrative of the embodiments and not restrictive. Many modifications and variations of the described embodiments are possible and are apparent to those of ordinary skill in the art. The selection of terms is made to best describe the principles of the embodiments, the practical application, or technical improvement over the technology found in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method for application development, comprising: generating, based on a workflow of a visualized application orchestrated on a zero-code platform, a first domain specific language file associated with the zero-code platform; generating, based on the first domain specific language file, a first executable code of the application; and using, in an integrated development environment, the first executable code for development of the application.

2. The method of claim 1, wherein generating the first domain specific language file associated with the zero-code platform comprises: obtaining node information and edge information of the workflow of the application; and generating, based on the node information and the edge information, the first domain specific language file.

3. The method of claim 1, wherein generating the first executable code of the application comprises: obtaining the node information and the edge information from the first domain specific language file; and generating, based on the node information and the edge information, the first executable code.

4. The method of claim 1, further comprising: generating, based on a second executable code associated with a custom node, a second domain specific language file; generating, based on the second domain specific language file, a visualized graphical representation of the custom node; and orchestrating the workflow of the application by adding the visualized graphical representation of the custom node to the zero-code platform.

5. The method of claim 1, further comprising: generating, based on a third executable code associated with a custom node, a software development kit; and orchestrating the workflow of the application by depending on and consuming the software development kit in the first executable code.

6. The method of claim 1, further comprising: preliminarily developing the application by adjusting a visualized graphical representation of the workflow.

7. The method of claim 1, wherein the application comprises a generative model application.

8. A system for application development, comprising: a first domain specific language file generation unit configured to generate, based on a workflow of a visualized application orchestrated on a zero-code platform, a first domain specific language file associated with the zero-code platform; a first executable code generation unit configured to generate, based on the first domain specific language file, a first executable code of the application; and an application development unit configured to use, in an integrated development environment, the first executable code for development of the application.

9. A computing device, comprising: at least one processing unit; at least one memory coupled to the at least one processing unit and storing instructions for execution by the at least one processing unit, the instructions, when executed by the at least one processing unit, cause the computing device to perform the method of any one of claims 1 to 7.

10. A computer storage medium comprising machine executable instructions that, when executed by a device, cause the device to perform the method of any one of claims 1 to 7. ​ ​ ​ ​ ​ ​ 11. A computer program product comprising machine executable instructions for causing a device, when executing the machine executable instructions, to perform the method of any one of claims 1 to 7.

Images