Application development method and device and program product

Abstract

The invention provides an application development method and device and a program product. According to the method, a first compiling interface is displayed in response to a first trigger operation, the first compiling interface is associated with a first software toolkit, and the first software toolkit is integrated in a pluggable form; and in response to the second trigger operation, the first function code is compiled into an intermediate code and / or compiled into a second function code in combination with the accessed first interface information base, the first function code is compiled in a first language form, and the second function code is presented in a second language form. According to the method, the quick debugging of the code can be realized and / or the second function code which can be directly matched with a native platform and has the performance comparable to that of a pure native application can be obtained through a unified development language without compiling the whole client project, and the development efficiency and the high performance during operation are both considered; and the development threshold and the development cost of the client application are better reduced.

Description

Technical Field

[0001] This implementation relates to the field of computer technology, and in particular to an application development method, apparatus, and program product. Background Technology

[0002] In the development of client applications, compiled languages ​​are required to write the code for the business functions in the application. After that, the code needs to go through processes such as compilation, linking and packaging to generate a runnable client application.

[0003] Typically, client-side applications are developed iteratively. Modifying client-side application code requires compiling the entire client project, and with increasingly large client projects, even a single code change can consume significant compilation time. Furthermore, to adapt to different runtime environments, client-side applications often require different programming languages ​​during development, further increasing development costs. These issues pose significant challenges to both the development experience and efficiency. Summary of the Invention

[0004] This technology provides an application development method, device, and program product, which solves the problem of low development efficiency caused by long compilation time required for each code modification, as well as the problem of high development cost and high development threshold caused by the need to use different programming languages ​​to write code to adapt to different operating environments.

[0005] Firstly, this embodiment provides an application development method, which includes: In response to a first trigger operation targeting the first entry point, a first compilation interface is displayed, the first entry point corresponding to a first software toolkit that can be plugged in and integrated; In response to a second trigger operation on the first compilation interface, and in conjunction with the accessed first interface information library, the first functional code is compiled into intermediate code, and / or into second functional code.

[0006] Secondly, this embodiment also provides an application development apparatus, including: The first response module is used to respond to a first trigger operation for the first entry point and display a first compilation interface. The first entry point corresponds to a first software toolkit that can be plugged in and integrated. The second response module is used to respond to a second trigger operation on the first compilation interface, and, in conjunction with the accessed first interface information library, compile the first function code into intermediate code, and / or compile it into second function code.

[0007] Thirdly, this embodiment also provides an electronic device, which includes: one or more processors; and a storage device for storing one or more programs, which, when executed by the one or more processors, enable the one or more processors to implement the application development method provided by any embodiment of the technology.

[0008] Fourthly, this embodiment also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the application development method provided by any embodiment of the technology.

[0009] Fifthly, this embodiment also provides a computer program product, including a computer program that, when executed by a processor, is used to implement the application development method as described in any embodiment of the art.

[0010] The technical solution of this embodiment, in response to a first trigger operation, displays a first compilation interface, which is associated with a first software toolkit, which is integrated in a pluggable manner. In response to a second trigger operation, it combines the accessed first interface information library to compile the first functional code into intermediate code, and / or into second functional code. The first functional code is written in a first language, and the second functional code is presented in a second language. Using this method, a pluggable integrated first software toolkit is used. After displaying the first compilation interface, in response to the second trigger operation, the first interface information library is invoked, and the selected first functional code in the first language is compiled into independently debuggable intermediate code and / or second functional code in the second language that can be deployed to a native platform based on the corresponding compilation mode. This allows for compilation of only selected code segments and rapid debugging based on reflection mechanisms when generating intermediate code. Compared to existing related technologies, this technical solution provides a pluggable, flexibly integrated first software toolkit, allowing existing client projects to easily integrate, solving the problems of high migration costs and inability to integrate into existing native projects due to technology stack disruptions. When generating second-function code, only the first-function code that meets the release requirements can be compiled without compiling the entire client project. By providing a unified development language, developers can obtain second-function code that can directly match the native platform and has performance comparable to pure native applications without having to master multiple programming languages. This balances development efficiency and high runtime performance, and further reduces the threshold and cost of client application development. Attached Figure Description

[0011] The above and other features, advantages, and aspects of the various embodiments of this technology will become more apparent when taken in conjunction with the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and the originals and elements are not necessarily drawn to scale.

[0012] Figure 1 A scenario diagram is provided illustrating the application scenarios involved in applications developed using the provided application development methodology; Figure 2 A flowchart illustrating an application development method provided by this implementation is given; Figure 3 A schematic diagram of the structure of an application development apparatus provided in this embodiment is given; Figure 4 A schematic diagram of the structure of an electronic device provided in this embodiment is given. Detailed Implementation

[0013] The embodiments of this technology will now be described in more detail with reference to the accompanying drawings. While some embodiments of this technology are shown in the drawings, it should be understood that the technology can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of the technology. It should be understood that the accompanying drawings and embodiments are for illustrative purposes only and are not intended to limit the scope of protection of this technology.

[0014] It should be understood that the steps described in the method implementation of this technology can be performed in different orders and / or in parallel. Furthermore, the method implementation may include additional steps and / or omit the steps shown. The scope of this technology is not limited in this respect.

[0015] The term "comprising" and its variations as used herein are open-ended inclusions, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least two embodiments"; the term "another embodiment" means "at least two additional embodiments"; the term "some embodiments" means "at least some embodiments". Definitions of other terms will be given in the following description.

[0016] It should be noted that the concepts of "first" and "second" mentioned in this technology are only used to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.

[0017] It should be noted that the terms "one" and "more" used in this technology are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0018] The names of the messages or information exchanged between the multiple devices in this technical embodiment are for illustrative purposes only and are not intended to limit the scope of these messages or information.

[0019] It is understandable that before using the technical solutions disclosed in various implementation methods of the technology, users should be informed of the types, scope of use, and usage scenarios of the personal information involved in the technology and their authorization should be obtained in accordance with relevant laws and regulations through appropriate means.

[0020] For example, upon receiving a user's proactive request, a prompt message can be sent to the user to explicitly inform them that the requested operation will require the acquisition and use of the user's personal information. This allows the user to independently choose whether to provide personal information to the software or hardware such as electronic devices, applications, servers, or storage media that perform the operation based on the prompt message.

[0021] As an optional but non-limiting implementation, in response to a user's active request, sending a prompt message to the user can be done via a pop-up window, where the prompt message can be presented in text format. Furthermore, the pop-up window can also include a selection control allowing the user to choose "agree" or "disagree" to provide personal information to the electronic device.

[0022] It is understood that the above notification and user authorization process are merely illustrative and do not constitute a limitation on the implementation of this technology. Other methods that comply with relevant laws and regulations may also be applied to the implementation of this technology.

[0023] It is understood that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) shall comply with the requirements of relevant laws, regulations and related provisions.

[0024] For example, Figure 1 The document provides scenario diagrams illustrating the application scenarios involved in applications developed using the provided application development methodology. Applications developed using this methodology can be applied to... Figure 1 In the application scenarios shown.

[0025] Among them, such as Figure 1As shown, terminal 102 communicates with server 104 via a communication network. A data storage system can store the data that server 104 needs to process. The data storage system can be integrated onto server 104 or located in the cloud or on other network servers. Terminal 102 can be, but is not limited to, various personal computers, laptops, smartphones, tablets, IoT devices, and portable wearable devices. IoT devices can include smart speakers, smart TVs, smart air conditioners, smart in-vehicle devices, etc. Portable wearable devices can include smartwatches, smart bracelets, head-mounted devices, etc. Server 104 can be implemented using a standalone server or a server cluster consisting of multiple servers.

[0026] It should be noted that, in one scenario, application development can be described as follows: taking client application development as an example, in the process of developing applications for mobile devices (such as smartphones and tablets), the code for business functions in the application can be written using a compiled language adapted to the runtime environment. After that, it is necessary to go through processes such as compilation, linking, and code packaging to generate a runnable client application.

[0027] As we know, client applications employ an iterative development approach, meaning that code changes to traditional client applications require compiling the entire client project. However, in real-world business scenarios, as client projects grow increasingly large, the number of files requiring compilation becomes enormous. Therefore, for large client projects, even a single code change can consume significant compilation time, severely impacting the development experience and efficiency. Furthermore, because client applications need to adapt to different runtime environments to ensure smooth operation, different programming languages ​​must be used during the development phase, further increasing the development cost of client applications.

[0028] To address the aforementioned issues, a related technical implementation proposed an open-source framework for building cross-platform native mobile applications. This framework, through a configured virtual machine combined with reflection, provides the ability to access and invoke native platform interfaces, thereby enabling rapid code debugging. However, this framework has certain limitations. As a complete application development framework, it cannot be seamlessly integrated into existing, large-scale native client projects. To utilize the functionality provided by this framework, client application development must begin within it from the outset. Therefore, existing client projects cannot be migrated to this framework, and modifications to the client application code still require recompiling the entire client project, while also considering the compatibility of the code written in the programming language with the runtime environment. Therefore, it can be argued that currently there is no good method for achieving efficient, convenient, and low-cost editing and development of existing client application projects.

[0029] Based on this, this implementation provides an application development method that enables simple and efficient development of newly created or existing client applications. Specifically, Figure 2 A flowchart illustrating an application development method provided by this embodiment is given. This embodiment is applicable to the development of client applications. The method can be executed by an application development device, which can be implemented in the form of software and / or hardware, and optionally, by an electronic device.

[0030] like Figure 2 As shown, the application development method provided in this embodiment may specifically include: S201. In response to the first trigger operation, a first compilation interface is displayed. The first compilation interface is associated with a first software toolkit, which is integrated in a pluggable manner.

[0031] The first compilation interface can be understood as a visual interface for compiling the developed code, allowing developers to initiate compilation-related operations directly on the interface. The first software toolkit can be considered a plug-in module that can be deployed independently and flexibly integrated into existing development platforms. It does not require project restructuring or changes to the original technology stack; it only needs to be installed as an installer and integrated through a simple configuration interface, enabling the installed development platform to have capabilities such as phased compilation and dynamic debugging. The first trigger operation can be considered as a trigger operation initiated against the first entry point to enter the compilation process, such as clicking, swiping, and / or dragging the first entry point. The first entry point can be understood as the trigger entry point provided after the first software toolkit is integrated.

[0032] In one scenario, when a development platform integrates a first software toolkit in a pluggable manner, it can provide a primary entry point for triggering the toolkit, such as a plugin button or switch control. When there is a need to add code or modify existing code within the project, a first trigger operation can be performed on the primary entry point. In response to the first trigger operation on the primary entry point, the first compilation interface can be displayed.

[0033] For example, the first compilation interface may include multiple compilation controls, each corresponding to one or more compilation operations in one mode. For example, the modes may include debug mode and non-debug mode (release mode). The first compilation interface may also include configuration controls for configuring the first software tool so that the first software tool can access the information repository or database in the development platform. The first compilation interface may also include code selection controls for triggering the display of a project list to select functional code that meets the compilation requirements.

[0034] S202. In response to the second trigger operation, and in conjunction with the accessed first interface information database, the first function code is compiled into intermediate code, and / or compiled into second function code. The first function code is written in the form of a first language, and the second function code is presented in the form of a second language.

[0035] The second trigger operation can be considered as a trigger operation initiated by any compilation control to start the compilation operation in the corresponding mode. The first interface information library can be understood as a standardized description library pre-collected and defined before client application development, used to provide a reliable basis for generating various types of code during the compilation phase. The first interface information library includes the required interface data content, which corresponds to the native platform application programming interface to be called, and is used to describe the identity information and calling rules of the native platform application programming interface. For example, the interface data content may include basic interface identity information, such as class name / interface name, native platform, version compatibility, and access permissions; the interface data content may also include method signature information, such as method name, parameter list, return value type, and exception declaration; the interface data content may also include field information, such as field name and field type; and the interface data content may also include type mapping rules, such as the type correspondence between the first language and the native language.

[0036] In one context, a first-language language can be considered a strongly typed language, characterized by fixed types, strict constraints, and a concise and flexible syntax. Fixed types mean that the types of variables and functions are determined at definition time, and mixing types without explicit conversion is not allowed. Strict constraints mean that type compatibility is rigorously checked during compilation and runtime to prevent vulnerabilities caused by type errors from the outset. The design goal of a first-language language is to efficiently and unambiguously map to the type system of the corresponding second-language language on the native platform, while also being efficiently executed by the deployed virtual machine, thus balancing development efficiency and code security, and supporting code compilation in multiple modes. A second-language language can be considered the coding language corresponding to the native platform, that is, a high-performance coding language in the native platform's runtime environment, which can be used for the final application installation package distribution.

[0037] The first functional code can be considered as the functional code in the project that has compilation requirements, that is, the original business code written by the developer in the first language. The intermediate code can be understood as the transitional code corresponding to the first functional code in debug mode. It is specially adapted to the running rules in the virtual machine so as to achieve efficient and dynamic debugging of the first functional code by running in the virtual machine, without affecting the performance of the final release. The second functional code can be considered as the native code generated by compilation that is suitable for the native platform to be released. It can run at high performance in the running environment of the corresponding native platform. The first functional code, intermediate code and second functional code describe the same business logic.

[0038] It is known that before performing the compilation operation, the developer needs to first determine the first functional code from the code written in the first language in the development platform, and then execute the compilation operation of the first functional code in the corresponding mode by initiating the second trigger operation in the first compilation interface.

[0039] Optionally, the method for determining the first function code can be optimized as follows: in response to a third triggering operation, the first function code is determined, and the first function code is selected from the project associated with the developed first application.

[0040] Here, the first application can be understood as a client application that the developer is currently developing; it can be an existing client application awaiting optimization or a newly developed client application. The project associated with the first application contains functional code written in the first language corresponding to the first application. The third trigger operation can be understood as a trigger operation used to select the first functional code from the project. For example, if the first compilation interface contains a project directory tree, the third trigger operation can be a selection of the project to be compiled, code files under the project, or code snippets within the project directory tree. If the first compilation interface only contains a control for initiating code selection (such as an import code button), the third trigger operation can be a combined trigger operation, including a trigger operation on the control itself, and a trigger operation on the project or code files under the project displayed in the first compilation interface after responding to the trigger operation.

[0041] In one scenario, when there is a need to determine the first functional code, the developer can initiate a third trigger operation on the corresponding control displayed in the first compilation interface. Accordingly, in response to the third trigger operation on the first compilation interface, the first functional code that requires compilation can be accurately determined.

[0042] Following the above description, after determining the first functional code, a second trigger operation can be initiated on the corresponding compilation control in the first compilation interface. Optionally, the first compilation interface includes a first compilation control, a second compilation control, and a third compilation control; the first compilation control is used to trigger the compilation of intermediate code, the second compilation control is used to trigger the compilation of the second functional code, and the second compilation control is used to simultaneously trigger the compilation of the intermediate code and the second functional code; the second trigger operation is achieved by triggering the generation of one of the first compilation control, the second compilation control, and the third compilation control.

[0043] The first compilation control can be understood as the compilation control corresponding to debug mode, used to trigger the execution logic of compiling the first functional code into independently debuggable intermediate code. For example, the first compilation control could be a button labeled "Debug Compilation" or "Quick Compilation". The second compilation control can be considered as the compilation control corresponding to release mode, used to trigger the execution logic of compiling the first functional code into second functional code that can be published to the native platform. For example, the second compilation control could be a button labeled "Release Compilation" or "Native Compilation". The third compilation control can be considered as the compilation control corresponding to both debug and release modes, used to simultaneously trigger the execution logic of compiling the first functional code into independently debuggable intermediate code and second functional code that can be published to the native platform. For example, the third compilation control could be a button labeled "Full Compilation" or "Integration Compilation".

[0044] Correspondingly, the second trigger operation can include triggering operations on the first compilation control, the second compilation control, and the third compilation control. For example, after a developer has just finished writing or modifying code and wants to quickly verify the logic's correctness, they can trigger the first compilation control to quickly generate the corresponding intermediate code. This intermediate code can then be quickly debugged in a deployed virtual machine using reflection to obtain debugging results, without waiting for the lengthy compilation of the entire client project. After the developer has completed code debugging and is ready for testing or deployment, they can trigger the second compilation control to generate second-function code that is identical to manually written code and suitable for the native platform. This second-function code can then be packaged into an installer or application, ensuring performance after release. Furthermore, during the pre-release phase, if a developer wants to quickly verify the final round of logic using intermediate code and also wants to generate second-function code in advance for packaging and testing to avoid repetitive operations, they can trigger the third compilation control.

[0045] The above technical solution provides a way to set up the compilation controls in the first compilation interface and a way to generate the second trigger operation, making the compilation operation more visual and precise, avoiding useless compilation, and providing support for achieving staged compilation to achieve efficient dynamic debugging and ensure the ultimate performance of application products.

[0046] In one scenario, upon receiving a second trigger operation targeting the first compilation interface, the first functional code is parsed in response to the second trigger operation to obtain the code parsing result. This result may include interface call requirements, such as the native platform interfaces that the first functional code needs to call. Next, the accessed first interface information database is searched to determine the interface data content matching the interface call requirements, ensuring that the compiled code can accurately interface with the corresponding application programming interface for smooth operation. Then, different compilation logic can be executed according to the compilation mode corresponding to the second trigger operation to compile the first functional code in the first language form into intermediate code and / or the second functional code in the second language form.

[0047] For example, the method of compiling the first functional code in the first language form into intermediate code can be as follows: the first functional code is converted into code that can be executed by the virtual machine based on the code parsing result; code matching the native platform application programming interface is further generated based on the code and interface data content; and then, based on the code, the first configuration information of the virtual machine is combined to generate intermediate code that can be run smoothly in the virtual machine runtime environment.

[0048] It is known that since the business logic is consistent across platforms, only the code segments corresponding to the business logic need to be converted to a different language. However, the API calls are specific to the native platform and require separate adaptation. Therefore, the method for compiling the first functional code in the first language form into the second functional code in the second language form can be as follows: Based on the code parsing results, determine the code segments related to business logic and those related to API calls in the first functional code. Convert the code segments related to business logic according to the language syntax specifications of the runtime environment provided by the first application. Then, adapt and convert the code segments related to API calls according to the API data content. Finally, integrate the converted business logic code and API call code to generate second functional code that is identical to manually written code and conforms to the native platform's syntax and API specifications.

[0049] The above technical solution, in response to a first trigger operation, displays a first compilation interface, which is associated with a first software toolkit, which is integrated in a pluggable manner. In response to a second trigger operation, it combines the accessed first interface information library to compile the first functional code into intermediate code, and / or into second functional code. The first functional code is written in a first language, and the second functional code is presented in a second language. Using this method, a pluggable integrated first software toolkit is used. After displaying the first compilation interface, in response to the second trigger operation, the first interface information library is invoked, and the selected first functional code in the first language is compiled into independently debuggable intermediate code and / or second functional code in the second language that can be deployed to a native platform. This allows for compilation of only selected code segments and rapid debugging based on reflection mechanisms when generating intermediate code. Compared to existing related technologies, this technical solution provides a pluggable, flexibly integrated first software toolkit, enabling existing client projects to easily integrate it, thus solving the problems of high migration costs and inability to integrate into existing native projects due to technology stack disruptions. When generating second-function code, only the first-function code that meets the release requirements can be compiled without compiling the entire client project. By providing a unified development language, developers can obtain second-function code that can directly match the native platform and has performance comparable to pure native applications without having to master multiple programming languages. This balances development efficiency and high runtime performance, and further reduces the threshold and cost of client application development.

[0050] As a first optional implementation, based on the above implementation, the first functional code can be compiled into intermediate code and / or into second functional code by combining the accessed first interface information library, specifically as follows: a1) Parse the first function code to obtain the code parsing result, which includes the interface call requirements.

[0051] In one scenario, parsing the first function's code can be done as follows: First, perform syntax analysis on the first function's code to check if it conforms to the syntax rules of the first language, such as whether the function definitions and variable declarations are legal. Next, perform semantic analysis on the first function's code, such as determining that the function's intent is to obtain a device identifier rather than calculate a value. Based on the analysis results, extract key information, such as interface call requirements, business logic instructions, and interface call statements, to form the code parsing result. For example, the interface call requirement may include the native platform's application programming interface to be called, as well as constraints such as the call parameters and return value types.

[0052] b1) Determine the interface data content from the first interface information database, wherein the interface data content matches the interface call requirement.

[0053] In one scenario, the first interface information database pre-stores records such as the identity information and calling rules of the application programming interfaces corresponding to each native platform. In order for the generated intermediate code and second function code to have cross-platform compatibility and correctly call the native functions, it is necessary to determine the interface data content that matches the interface calling requirements by searching the first interface information database and combining it with a matching strategy, thereby obtaining the complete calling rules of the native platform application programming interfaces.

[0054] c1) Based on the code parsing results and the interface data content, obtain the intermediate code, which is used for code debugging; and / or, based on the code parsing results and the interface data content, obtain the second functional code, which is used for code release.

[0055] The first compilation logic can be considered as the compilation logic designed to achieve efficient dynamic debugging of code; the second compilation logic can be considered as the compilation logic designed to ensure that the generated code achieves native performance and can be directly deployed to the native platform.

[0056] In one scenario, the compilation logic to be used can be determined based on the compilation mode corresponding to the second triggering operation. Then, based on the code parsing results and interface data content, and according to different requirements for code debugging or code release, the corresponding code form can be generated in combination with the corresponding compilation logic, including lightweight, dynamic intermediate code and / or complete, static second function code.

[0057] In one scenario, the above technical solution provides an implementation method that combines the accessed first interface information library to compile the first functional code in the first language into the corresponding code form according to different development stage modes. This solves the problem of time-consuming compilation in cross-platform development, ensures the performance requirements of native applications, and lowers the threshold for client application development.

[0058] As one implementation method, the intermediate code obtained based on the code parsing results and the interface data content can be further optimized into the following steps: c11) Based on the business logic instructions in the code parsing result, the first functional code is converted into first intermediate code, the first intermediate code is adapted to the first virtual machine, and the first virtual machine is deployed in the first software toolkit.

[0059] The first virtual machine can be understood as a virtual machine deployed in the first software toolkit for executing intermediate code and supporting dynamic invocation of native platform application programming interfaces. Business logic instructions can be considered as instructions in the first functional code used to describe the execution of business logic. The first intermediate code can be considered as code corresponding to the business logic, adapted to the first virtual machine, and containing interface call placeholders. The interface call placeholders can be understood as empty positions reserved in the first intermediate code, used to fill in the code corresponding to the specific instructions for interface calls.

[0060] In one scenario, business logic instructions can be extracted from the first functional code based on the code parsing results. Then, these business logic instructions are converted into code adapted to the first virtual machine, such as bytecode, according to the predefined format of the first virtual machine. Based on the position of the original interface call instructions or code in the first functional code, interface call placeholders are reserved in the corresponding positions of the code adapted to the first virtual machine, thereby forming the first intermediate code.

[0061] c12) Based on the interface data content, generate a second intermediate code, which contains interface metadata information.

[0062] The interface metadata information may include the class name, method signature, and type mapping of the native platform's application programming interface.

[0063] In one scenario, the method for generating second intermediate code containing interface metadata information based on the interface data content can be as follows: extract interface metadata information from the interface data content, convert the interface metadata information into second intermediate code that can be recognized by the first virtual machine, and the second intermediate code can be considered as code containing the necessary information for calling the native platform application programming interface (such as parameters of reflection call and return value processing) to ensure that the native platform application programming interface can be accurately and flexibly called subsequently.

[0064] c13) Replace the interface call placeholder with the second intermediate code to obtain the third intermediate code, wherein the interface call placeholder exists in the first intermediate code.

[0065] In one scenario, by filling the interface call placeholder positions of the first intermediate code with the second intermediate code, the complete business logic and precise interface calls can be integrated, thereby forming a third intermediate code that is compatible with the first virtual machine and has the foundation for execution.

[0066] c14) Based on the third intermediate code and the first configuration information, generate the intermediate code, where the first configuration information is the environment configuration information of the first virtual machine. In one scenario, the first configuration information can be obtained, such as supported instruction set versions, memory limits, reflection call timeouts, and log output rules; then, the execution environment of the third intermediate code is adapted and optimized according to the first configuration information, such as verifying whether the third intermediate code meets the version requirements of the first virtual machine and adding context information, thereby generating the final intermediate code that can be directly run in the first virtual machine.

[0067] In one scenario, the above technical solution provides an implementation method for generating intermediate code. By compiling business logic and interface calls separately, when modifying interface call rules, it is not necessary to recompile the entire business logic; only the second intermediate code needs to be regenerated. This improves compilation speed and cross-platform adaptability. Furthermore, by integrating the first intermediate code containing business logic and the second intermediate code containing interface metadata information, and combining the first configuration information to generate intermediate code, the stability and maintainability of debugging are further enhanced.

[0068] As another implementation method, obtaining the second functional code based on the code parsing result and the interface data content can be further specified as follows: c15) Obtain the interface call statements and business logic instructions in the code parsing results, and determine the functional execution logic of the first functional code based on the business logic instructions.

[0069] Among them, the interface call statement can be considered as a code snippet used to directly call the application programming interface of the native platform.

[0070] In one scenario, after obtaining the business logic instructions from the code parsing results, the functional execution logic of the first functional code can be extracted from these instructions. This functional execution logic can be considered a structured description of the business logic. For example, the functional execution logic could be: declaring variables → calling a generic unique identifier to generate an application programming interface (API) → calling a string conversion API → returning the result.

[0071] c16) Based on the language syntax specifications of the first runtime environment, convert the function execution logic into business logic code.

[0072] In one scenario, the first runtime environment is the runtime environment that supports the development of the first application, that is, the runtime environment provided by the native platform to which the second functional code is to be deployed. It is known that each native platform corresponds to a specific programming language, and correspondingly, each runtime environment will have its own unique language syntax specifications. To ensure the native compliance of the business logic, the functional execution logic can be converted into business logic code according to the language syntax specifications of the first runtime environment, such as function definitions, variable declarations, and return value rules. This ensures that the business logic code fully conforms to the language syntax specifications of the first runtime environment without logical deviation, and is consistent with manually written native code.

[0073] c17) Based on the interface data content, the interface call statement is converted into interface call code, and the interface call code is adapted to the first running environment.

[0074] In one scenario, the precise calling rules of the application programming interface (API) of the native platform corresponding to the first runtime environment can be obtained from the API data content, such as static method calling rules and instance method calling rules. Based on the calling rules, the API call statement is converted into API call code adapted to the first runtime environment, so that the API call code can directly call the API of the native platform, thus ensuring runtime performance.

[0075] c18) Integrate the business logic code and the interface call code to obtain the second function code.

[0076] In one scenario, when generating business logic code in step c16, a corresponding empty space is reserved in the business logic code based on the position of the interface call statement in the first functional code. Correspondingly, the method for integrating the business logic code and the interface call code in this step to obtain the second functional code can be: filling the corresponding empty space in the business logic code with the interface call code to generate the second functional code. Optionally, the business logic code and the interface call code can also be concatenated according to preset rules to generate the second functional code.

[0077] Optionally, after generating the second function code, it can be packaged into an application package for distribution and installation on the native platform.

[0078] The above technical solution converts the functional execution logic into business logic code according to the language syntax specifications of the first operating environment, and converts the interface call statements into interface call code adapted to the first operating environment according to the interface data content. This ensures the correctness and feasibility of the business logic and interface calls in the first operating environment. By integrating the business logic code and interface call code to generate the second functional code, the second functional code retains the original business logic and fully complies with the syntax and interface call specifications of the native platform, thereby ensuring the performance and compatibility of the code release stage.

[0079] As a second alternative implementation method, based on the above implementation method, it can be further optimized to include: a2) Based on the intermediate code, obtain and display the debugging results of the first functional code; and / or, incrementally update the second functional code to the project of the developed first application so that the first application has the business capabilities of the second functional code.

[0080] Understandably, the development platform needs to call code on the client during debugging, so the development platform needs to connect to the device with the application client installed during the code debugging process.

[0081] In one scenario, determining and displaying the debugging result of the first functional code based on the intermediate code can be achieved as follows: The generated intermediate code is loaded and executed by a first virtual machine in a first software toolkit. During execution, the application programming interface related to the first application can be called via reflection to interact with the native runtime environment. Next, the debugging result after executing the intermediate code is obtained. The debugging result can be categorized into normal results under normal running conditions and abnormal results under abnormal running conditions. The debugging result can then be displayed in the first compilation interface using logs, pop-ups, etc.

[0082] For example, a normal result may include a successful execution status, a successfully returned running result, and / or execution time. An abnormal result may include a failed execution status, error type, error cause (such as API call timeout, type conversion error, and / or insufficient permissions), error location, and / or repair suggestions. By using closed-loop debugging and visualizing the debugging results, debugging efficiency and the accuracy of problem localization are improved, and the debugging threshold is lowered.

[0083] In one scenario, the method of incrementally updating the second function code to the project of the developed first application can be as follows: based on the project configuration of the first application (such as the directory structure and code organization rules of the project), determine the target location for updating the second function code; make a precise comparison between the newly generated second function code and the existing code at the corresponding location in the project to determine the incremental update operation and scope, and then execute the incremental code update.

[0084] For example, if the corresponding file does not exist in the project, the incremental update operation is determined to be an addition, and the second function code file is directly copied to the target location; if the corresponding file exists in the project and the code differs, the incremental update operation is determined to be a replacement, and only the differing functions / code snippets in the file can be replaced while retaining other unchanged content, or the corresponding original code can be directly replaced with the second function code; if the corresponding file exists in the project but the code is unchanged, the update can be skipped to avoid meaningless changes. Optionally, after the incremental update, an incremental build of the project can be triggered to compile the modified files and check the results of the incremental build.

[0085] The above technical solution, by incrementally updating the second function code to the project of the first application being developed, not only ensures code implementation but also improves release efficiency.

[0086] As one implementation method, obtaining and displaying the debugging results of the first functional code based on the intermediate code can be further specified as the following steps: a21) Load the intermediate code into the first virtual machine, which is deployed in the first software toolkit.

[0087] In one scenario, the generated intermediate code can be fully loaded into the first virtual machine, allowing it to enter a runnable environment for subsequent code debugging, thus avoiding interference or risks caused by directly manipulating the native project. It is known that the first virtual machine built into the first software toolkit has a pre-initialized virtual machine environment, such as memory allocation and reflection call rules, ensuring the stability of the intermediate code's execution.

[0088] a22) Using the first virtual machine, based on the interface metadata information in the intermediate code and combined with the reflection mechanism, the interface function is called and the execution of the interface function is controlled. The interface function is related to the first application.

[0089] It should be noted that if the virtual machine only simulates interface calls locally (rather than calling the actual device interfaces), the debugging results will be inconsistent with the results of running on a real device, thus defeating the purpose of debugging. Therefore, the first virtual machine establishes a communication connection with the device where the first application resides before code debugging, and this device has all system-level application programming interfaces built-in, as well as custom interface functions already integrated into the project associated with the first application.

[0090] In one scenario, the first virtual machine can obtain the corresponding interface metadata information by parsing the intermediate code. Based on the interface metadata information, it can find the interface function related to the first application through reflection and provide the interface function to the connected device so that the device can determine the matching native interface function based on the interface function. Then, the interface function can be controlled to be executed on the device by passing parameters, setting execution timeout and running instructions.

[0091] a23) Obtain the execution result of the interface function, and run the business logic content based on the execution result to obtain execution feedback information. The business logic content is included in the intermediate code.

[0092] In one scenario, the first virtual machine can obtain the execution result of the corresponding interface function from the device after the interface function execution is completed. For example, the execution result of the interface function may include a normal success result and an abnormal failure result. Then, based on the execution result, the business logic content in the intermediate code can continue to run in the first virtual machine to obtain the execution result of the business logic. The execution result of the interface function and the execution result of the business logic are then integrated to generate execution feedback information.

[0093] For example, when the execution result of an interface function is a normal result (running normally), the execution result may include information such as the returned object. Correspondingly, the execution feedback information generated after running the business logic based on the execution result may include success / failure status, return value, exception information, and / or execution time. When the execution result of an interface function is an abnormal result (abnormal execution), the execution result may include the error type, error reason, and error location. Correspondingly, when running the business logic based on the execution result, the business logic will be interrupted, so the generated execution feedback information may include failure status, exception information, and / or execution time.

[0094] a24) The execution feedback information is processed in a structured manner to obtain and display the debugging results.

[0095] In one scenario, execution feedback information can be structured according to a preset fixed format, unifying field names and display rules to generate debugging results. These results can then be displayed in the first compilation interface, and additional interactive support such as copying results, re-debugging, and viewing detailed logs can be provided.

[0096] Optionally, if the debugging results are normal, a second functional code adapted to the first application's runtime environment (native platform) can be generated based on the first functional code.

[0097] In one scenario, the above technical solution provides an implementation method for automatically running the generated intermediate code and forming debugging results, which improves the efficiency of dynamic code debugging, the accuracy of debugging results, and the user-friendliness of the debugging results display, thereby enhancing the debugging experience.

[0098] As a third alternative implementation method, based on the above implementation method, it can be further optimized to include: a3) Display the configuration interface of the first software toolkit and obtain the information database association parameters, which are configured in the configuration interface.

[0099] It is known that the first interface information library is deployed on the development platform rather than within the first software toolkit. The first software toolkit is flexibly integrated into the development platform in a plug-and-play manner. Therefore, the first software toolkit does not contain the first interface information library. It is necessary to actively access the first interface information library on the development platform to ensure the normal operation of subsequent compilation, debugging and other operations.

[0100] Therefore, in one scenario, after the first software toolkit is integrated into the development platform, it can display a visual configuration interface on the development platform for associating with the first interface database. For example, the configuration interface can be in form, including configuration items such as the database server address, database access token, database version, and connection timeout. Then, the first software toolkit can obtain database association parameters relative to the configuration items input through the configuration interface, such as the specific token value corresponding to the database access token configuration item and the version value corresponding to the database version configuration item.

[0101] b3) Perform the access operation of the first interface information database based on the information database association parameters, and display the access status.

[0102] In one scenario, the first software toolkit can first verify the database association parameters, such as whether the server address is compliant and the token format is correct. If the verification passes, the database association parameters are persistently stored; if the verification fails, a prompt is given, and the database association parameters are retrieved and verified again until the verification passes. Then, in response to automatically generated access trigger operations or trigger operations of access controls in the configuration interface, the access operation to the first interface database can be performed based on the database association parameters. For example, the access operation to the first interface database based on the database association parameters can be performed as follows: read the saved database association parameters, initiate a network request to connect to the first interface database server based on the server address, initiate access permission verification based on the database access token value, and access the first interface database if the verification passes.

[0103] In one scenario, the access status determined after initiating the access operation can be displayed. The access status can include successful access and access failure. In the case of successful access, the access status can also include information such as the database address and database version; in the case of access failure, the access status can also include information such as the reason for failure (e.g., server address unreachable, permission verification failure, and / or database version not existing), error code, and repair suggestions.

[0104] The above technical solution provides an implementation method for the pluggable integrated first software toolkit to access the first interface information library through a configuration interface, ensuring the smooth progress of subsequent compilation, debugging and other operations. Furthermore, by replacing manual modification of configuration files with a visual configuration interface, the configuration threshold is lowered, the configuration flexibility and ease of use are improved, and real-time feedback is achieved by displaying the access status, so that developers can know whether the access is successful immediately without manual testing, thereby improving the developer experience and configuration efficiency.

[0105] As a fourth alternative implementation method, based on the above implementation methods, it can be further optimized to include: a4) Display the first compilation result, and / or display the second compilation result; the first compilation result is displayed after the intermediate code is obtained, and the second compilation result is displayed after the second functional code is obtained.

[0106] In one scenario, the first compilation result can be understood as the compilation result corresponding to the intermediate code, used to indicate whether the intermediate code was successfully generated; the second compilation result can be considered as the compilation result corresponding to the second functional code, used to indicate whether the second functional code was successfully generated. For example, both types of compilation results can include a compilation status (success / failure). When the compilation status is successful, it can also include the storage path of the intermediate code, while when the compilation status is failed, it can also include the reason for the failure, the location of the misalignment, and repair suggestions. Furthermore, the compilation result can also include information such as compilation time.

[0107] In one scenario, after generating intermediate code and / or secondary function code, the corresponding compilation results can be displayed in the first compilation interface. This allows developers to know the code compilation status immediately without manually checking files or logs, thus avoiding the exposure of compilation failures during subsequent operation, improving development efficiency and experience, and reducing troubleshooting costs.

[0108] Figure 3 A schematic diagram of the structure of an application development apparatus provided in this embodiment is given, such as... Figure 3 As shown, the device includes: a first response module 31 and a second response module 32.

[0109] The first response module 31 is used to respond to the first trigger operation and display the first compilation interface. The first compilation interface is associated with the first software toolkit, and the first software toolkit is integrated in a pluggable form. The second response module 32 is used to respond to the second trigger operation, and in conjunction with the accessed first interface information library, compile the first function code into intermediate code, and / or compile it into second function code. The first function code is written in a first language and the second function code is presented in a second language.

[0110] This embodiment provides an application development apparatus that, in response to a first trigger operation, displays a first compilation interface associated with a first software toolkit, which is integrated in a pluggable manner. In response to a second trigger operation, it combines a first interface information library to compile first functional code into intermediate code and / or into second functional code. The first functional code is written in a first language, and the second functional code is presented in a second language. Using this apparatus, a pluggable integrated first software toolkit is employed. After displaying the first compilation interface, in response to a second trigger operation, the first interface information library is invoked, and the selected first functional code in the first language is compiled into independently debuggable intermediate code and / or second functional code in the second language that can be deployed to a native platform, based on a corresponding compilation mode. This allows for compilation of only selected code segments and rapid debugging based on reflection mechanisms when generating intermediate code. Compared to existing related technologies, this technical solution provides a pluggable, flexibly integrated first software toolkit, enabling existing client projects to easily integrate and solving the problems of high migration costs and inability to integrate into existing native projects due to technology stack disruptions. When generating second-function code, only the first-function code that meets the release requirements can be compiled without compiling the entire client project. By providing a unified development language, developers can obtain second-function code that can directly match the native platform and has performance comparable to pure native applications without having to master multiple programming languages. This balances development efficiency and high runtime performance, and further reduces the threshold and cost of client application development.

[0111] Furthermore, the second response module 32 may specifically include: A parsing unit is used to parse the first function code and obtain code parsing results, the code parsing results including interface call requirements; A matching unit is used to determine interface data content from the first interface information database, wherein the interface data content matches the interface call requirement; The first compilation unit is used to obtain the intermediate code based on the code parsing results and the interface data content, and the intermediate code is used for code debugging. And / or, The second compilation unit is used to obtain the second functional code based on the code parsing results and the interface data content. The second functional code is used for code release.

[0112] Furthermore, the first compilation unit can specifically be used for: Based on the business logic instructions in the code parsing results, the first functional code is converted into first intermediate code, the first intermediate code is adapted to the first virtual machine, and the first virtual machine is deployed in the first software toolkit; Based on the interface data content, a second intermediate code is generated, which contains interface metadata information; The second intermediate code is used to replace the interface call placeholder to obtain the third intermediate code, wherein the interface call placeholder exists in the first intermediate code; Based on the third intermediate code and the first configuration information, the intermediate code is obtained, wherein the first configuration information is the environment configuration information of the first virtual machine.

[0113] Furthermore, the second compilation unit can specifically be used for: Obtain the interface call statements and business logic instructions from the code parsing results, and determine the functional execution logic of the first functional code based on the business logic instructions; According to the language syntax specifications of the first runtime environment, the functional execution logic is converted into business logic code. The first runtime environment is the runtime environment that supports the running of the developed first application. Based on the interface data content, the interface call statement is converted into interface call code, and the interface call code is adapted to the first running ring; By integrating the business logic code and the interface call code, the second functional code is obtained.

[0114] Furthermore, the device also includes a debugging result display module and / or an incremental update module. The debugging result display module is used to obtain and display the debugging result of the first functional code based on the intermediate code. The incremental update module is used to incrementally update the second function code to the project of the developed first application, so that the first application has the business capabilities of the second function code.

[0115] Furthermore, the debugging result display module can specifically be used for: The intermediate code is loaded into a first virtual machine, which is deployed in the first software toolkit; Using the first virtual machine, based on the interface metadata information in the intermediate code, and combined with the reflection mechanism, the interface function is invoked and its execution is controlled. The interface function is related to the first application. Obtain the execution result of the interface function, run the business logic based on the execution result, and obtain execution feedback information. The business logic is included in the intermediate code. The execution feedback information is processed in a structured manner to obtain and display the debugging results.

[0116] Furthermore, the first compilation interface includes a first compilation control, a second compilation control, and a third compilation control; the first compilation control is used to trigger the compilation of intermediate code, the second compilation control is used to trigger the compilation of second function code, and the second compilation control is used to simultaneously trigger the compilation of intermediate code and second function code; The second triggering operation is generated by triggering one of the first compilation control, the second compilation control, and the third compilation control.

[0117] Furthermore, the device also includes a first function code determination module, which can be specifically used for: In response to a third triggering operation, the first function code is determined, and the first function code is selected from the project associated with the developed first application.

[0118] Furthermore, the device also includes an access unit, which can specifically be used for: The configuration interface of the first software toolkit is displayed, as well as the information database association parameters are obtained. The information database association parameters are configured in the configuration interface. The system performs an access operation to the first interface information database based on the information database association parameters and displays the access status.

[0119] Furthermore, the device also includes a compilation result display module, which can be specifically used for: Display a first compilation result, and / or display a second compilation result; the first compilation result is displayed after the intermediate code is obtained, and the second compilation result is displayed after the second functional code is obtained.

[0120] The application development apparatus provided in this embodiment can execute the application development method provided in any embodiment of this technology, and has the corresponding functional modules and beneficial effects of executing the method.

[0121] It is worth noting that the various units and modules included in the above-mentioned device are only divided according to functional logic, but are not limited to the above division, as long as the corresponding functions can be realized; in addition, the specific names of each functional unit are only for easy differentiation and are not used to limit the protection scope of this embodiment.

[0122] Figure 4 A schematic diagram of the structure of an electronic device provided in this embodiment is given below. (Refer to...) Figure 4 It shows an electronic device suitable for implementing this embodiment (e.g., Figure 4The diagram below shows the structure of the terminal device (or server) 400. The terminal device in this embodiment may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital radio receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), and in-vehicle terminals (e.g., in-vehicle navigation terminals), as well as fixed terminals such as digital TVs and desktop computers. Figure 4 The electronic device shown is merely an example and should not impose any limitations on the functionality and scope of use of this implementation.

[0123] like Figure 4 As shown, electronic device 400 may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 401, which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 402 or a program loaded from storage device 408 into random access memory (RAM) 403. RAM 403 also stores various programs and data required for the operation of electronic device 400. Processing unit 401, ROM 402, and RAM 403 are interconnected via bus 404. Edit / output (I / O) interface 405 is also connected to bus 404.

[0124] Typically, the following devices can be connected to I / O interface 405: input devices 406 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 407 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 408 including, for example, magnetic tapes, hard disks, etc.; and communication devices 409. Communication device 409 allows electronic device 400 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 4 An electronic device 400 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0125] In particular, according to embodiments of this technology, the processes described in the above-referenced flowcharts can be implemented as computer software programs. For example, embodiments of this technology include a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication device 409, or installed from storage device 408, or installed from ROM 402. When the computer program is executed by processing device 401, it performs the functions defined in the method of this embodiment.

[0126] The names of the messages or information exchanged between the multiple devices in this technical embodiment are for illustrative purposes only and are not intended to limit the scope of these messages or information.

[0127] The electronic device provided in this embodiment belongs to the same inventive concept as the application development method provided in the above embodiment. Technical details not described in detail in one case can be found in the above embodiment, and in one case, it has the same beneficial effects as the above embodiment.

[0128] This embodiment provides a computer storage medium on which a computer program is stored, which, when executed by a processor, implements the application development method provided in the above embodiment.

[0129] It should be noted that the computer-readable medium described above in this technology can be a computer-readable signal medium, a computer-readable storage medium, or any combination of the two. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor device, apparatus, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this technology, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution apparatus, device, or device. In this technology, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution device, apparatus, or apparatus. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0130] In some implementations, clients and servers can communicate using any currently known or future-developed network protocol, such as HTTP (Hypertext Transfer Protocol), and can interconnect with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet of Things), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future-developed networks.

[0131] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0132] The aforementioned computer-readable medium carries one or more programs. When the aforementioned one or more programs are executed by the electronic device, the electronic device causes the electronic device to: respond to a first trigger operation, display a first compilation interface, the first compilation interface being associated with a first software toolkit, the first software toolkit being integrated in a pluggable manner; and respond to a second trigger operation, in conjunction with the accessed first interface information library, compile a first functional code into intermediate code, and / or compile it into a second functional code, the first functional code being written in a first language, and the second functional code being presented in a second language.

[0133] Computer program code for performing the operations of this technology can be written in one or more programming languages ​​or a combination thereof. These programming languages ​​include, but are not limited to, object-oriented programming languages—such as Java, Smalltalk, and C++—as well as conventional procedural programming languages—such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0134] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods, and computer program products according to various embodiments of the technology. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using dedicated hardware-based devices that perform the specified functions or operations, or using a combination of dedicated hardware and computer instructions.

[0135] The units described in this embodiment can be implemented in software or hardware. The name of a unit does not necessarily limit the unit itself; for example, the first acquisition unit can also be described as "a unit that acquires at least two Internet Protocol addresses".

[0136] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), devices-on-chip (SoCs), complex programmable logic devices (CPLDs), and so on.

[0137] In the context of this technology, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution apparatus, device, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0138] According to one or more embodiments of this technology, [Example 1] provides an application development method, including: in response to a first trigger operation, displaying a first compilation interface, the first compilation interface being associated with a first software toolkit, the first software toolkit being integrated in a pluggable manner; in response to a second trigger operation, in conjunction with an accessed first interface information library, compiling a first functional code into intermediate code, and / or compiling it into a second functional code, the first functional code being written in a first language, and the second functional code being presented in a second language.

[0139] According to one or more embodiments of this technology, [Example 2] provides the method of Example 1. Optionally, the step of compiling the first functional code into intermediate code and / or into second functional code in conjunction with the accessed first interface information library includes: parsing the first functional code to obtain a code parsing result, the code parsing result including interface call requirements; determining interface data content from the first interface information library, the interface data content matching the interface call requirements; obtaining the intermediate code based on the code parsing result and the interface data content, the intermediate code being used for code debugging; and / or obtaining the second functional code based on the code parsing result and the interface data content, the second functional code being used for code release.

[0140] According to one or more embodiments of this technology, Example 3 provides the method of Example 2. Optionally, obtaining the intermediate code based on the code parsing result and the interface data content includes: converting the first functional code into first intermediate code based on the business logic instructions in the code parsing result, the first intermediate code being adapted to a first virtual machine, the first virtual machine being deployed in the first software toolkit; generating second intermediate code based on the interface data content, the second intermediate code containing interface metadata information; replacing the interface call placeholder with the second intermediate code to obtain third intermediate code, the interface call placeholder existing in the first intermediate code; and obtaining the intermediate code based on the third intermediate code and first configuration information, the first configuration information being the environment configuration information of the first virtual machine.

[0141] According to one or more embodiments of this technology, Example 4 provides the method of Example 2. Optionally, obtaining the second functional code based on the code parsing result and the interface data content includes: obtaining the interface call statement and business logic instruction in the code parsing result, and determining the functional execution logic of the first functional code based on the business logic instruction; converting the functional execution logic into business logic code according to the language syntax specification of the first runtime environment, wherein the first runtime environment is a runtime environment that supports the operation of the developed first application; converting the interface call statement into interface call code according to the interface data content, wherein the interface call code is adapted to the first runtime environment; and integrating the business logic code and the interface call code to obtain the second functional code.

[0142] According to one or more embodiments of the technology, Example 5 provides the method of Example 1, which optionally further includes: obtaining and displaying the debugging results of the first functional code based on the intermediate code; and / or incrementally updating the second functional code to the project of the developed first application so that the first application has the business capabilities of the second functional code.

[0143] According to one or more embodiments of this technology, Example Six provides the method of Example Five. Optionally, obtaining and displaying the debugging result of the first functional code based on the intermediate code includes: loading the intermediate code into a first virtual machine, the first virtual machine being deployed in the first software toolkit; through the first virtual machine, based on the interface metadata information in the intermediate code and combined with a reflection mechanism, calling an interface function and controlling the execution of the interface function, the interface function being related to the first application; obtaining the execution result of the interface function, and running business logic content based on the execution result to obtain execution feedback information, the business logic content being included in the intermediate code; and structuring the execution feedback information to obtain and display the debugging result.

[0144] According to one or more embodiments of the technology, Example 7 provides a method of any one of Examples 1 to 6. Optionally, the first compilation interface includes a first compilation control, a second compilation control, and a third compilation control; the first compilation control is used to trigger intermediate code compilation, the second compilation control is used to trigger second function code compilation, and the second compilation control is used to simultaneously trigger the compilation of intermediate code and second function code; the second triggering operation is generated by triggering one of the first compilation control, the second compilation control, and the third compilation control.

[0145] According to one or more embodiments of the technology, Example 8 provides a method of any one of Examples 1 to 6, which may optionally further include: in response to a third triggering operation, determining the first function code, the first function code being selected from a project associated with the developed first application.

[0146] According to one or more embodiments of the technology, [Example Nine] provides a method of any one of Examples One to Six, which optionally further includes: displaying the configuration interface of the first software toolkit and obtaining information database association parameters, wherein the information database association parameters are configured in the configuration interface; performing an access operation to the first interface information database based on the information database association parameters, and displaying the access status.

[0147] According to one or more embodiments of the technology, Example 10 provides a method of any one of Examples 1 to 6, which may optionally further include: displaying a first compilation result, and / or displaying a second compilation result; the first compilation result is displayed after the intermediate code is obtained, and the second compilation result is displayed after the second functional code is obtained.

[0148] According to one or more embodiments of this technology, [Example 11] provides an application development apparatus, the apparatus comprising: a first response module, configured to display a first compilation interface in response to a first trigger operation, the first compilation interface being associated with a first software toolkit, the first software toolkit being integrated in a pluggable manner; and a second response module, configured to, in response to a second trigger operation, compile a first functional code into intermediate code, and / or, compile it into a second functional code, in conjunction with an accessed first interface information library, the first functional code being written in a first language, and the second functional code being presented in a second language.

[0149] The above description is merely a preferred embodiment of the technology and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of disclosure in this technology is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features disclosed in this technology that have similar functions.

[0150] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. Multitasking and parallel processing may be advantageous in certain environments. Similarly, while several specific implementation details are included in the above discussion, these should not be interpreted as limiting the scope of the technique. Certain features described in the context of individual implementations may also be implemented in combination in a single implementation. Conversely, various features described in the context of a single implementation may also be implemented individually or in any suitable sub-combination in multiple implementations.

[0151] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. An application development method, comprising: In response to a first trigger operation, a first compilation interface is displayed, which is associated with a first software toolkit, which is integrated in a pluggable manner. In response to the second trigger operation, and in conjunction with the accessed first interface information library, the first functional code is compiled into intermediate code, and / or compiled into second functional code, wherein the first functional code is written in a first language and the second functional code is presented in a second language.

2. The method according to claim 1, wherein compiling the first functional code into intermediate code and / or into second functional code in conjunction with the accessed first interface information database comprises: Parse the code of the first function to obtain the code parsing result, which includes the interface call requirements; The interface data content is determined from the first interface information database, and the interface data content matches the interface call requirement; Based on the code parsing results and the interface data content, the intermediate code is obtained, and the intermediate code is used for code debugging; And / or, Based on the code parsing results and the interface data content, the second function code is obtained, and the second function code is used for code release.

3. The method according to claim 2, wherein obtaining the intermediate code based on the code parsing result and the interface data content includes: Based on the business logic instructions in the code parsing results, the first functional code is converted into first intermediate code, the first intermediate code is adapted to the first virtual machine, and the first virtual machine is deployed in the first software toolkit; Based on the interface data content, a second intermediate code is generated, which contains interface metadata information; The second intermediate code is used to replace the interface call placeholder to obtain the third intermediate code, wherein the interface call placeholder exists in the first intermediate code; Based on the third intermediate code and the first configuration information, the intermediate code is obtained, wherein the first configuration information is the environment configuration information of the first virtual machine.

4. The method according to claim 2, wherein obtaining the second functional code based on the code parsing result and the interface data content includes: Obtain the interface call statements and business logic instructions from the code parsing results, and determine the functional execution logic of the first functional code based on the business logic instructions; According to the language syntax specifications of the first runtime environment, the functional execution logic is converted into business logic code. The first runtime environment is the runtime environment that supports the running of the developed first application. Based on the interface data content, the interface call statement is converted into interface call code, and the interface call code is adapted to the first runtime environment; By integrating the business logic code and the interface call code, the second functional code is obtained.

5. The method according to claim 1, further comprising: Based on the intermediate code, obtain and display the debugging results of the first functional code; And / or, The second function code is incrementally updated to the project of the developed first application so that the first application has the business capabilities of the second function code.

6. The method according to claim 5, wherein obtaining and displaying the debugging result of the first functional code based on the intermediate code includes: The intermediate code is loaded into a first virtual machine, which is deployed in the first software toolkit; Through the first virtual machine, based on the interface metadata information in the intermediate code and combined with the reflection mechanism, the interface function is called and the execution of the interface function is controlled. The interface function is related to the first application. Obtain the execution result of the interface function, run the business logic based on the execution result, and obtain execution feedback information. The business logic is included in the intermediate code. The execution feedback information is processed in a structured manner to obtain and display the debugging results.

7. The method according to any one of claims 1-6, wherein the first compilation interface includes a first compilation control, a second compilation control, and a third compilation control; the first compilation control is used to trigger intermediate code compilation, the second compilation control is used to trigger second function code compilation, and the second compilation control is used to simultaneously trigger the compilation of intermediate code and second function code; The second triggering operation is achieved by triggering the generation of one of the first compilation control, the second compilation control, and the third compilation control.

8. The method according to any one of claims 1-6, further comprising: In response to a third triggering operation, the first function code is determined, and the first function code is selected from the project associated with the developed first application.

9. The method according to any one of claims 1-6, further comprising: The configuration interface of the first software toolkit is displayed, as well as the information database association parameters are obtained. The information database association parameters are configured in the configuration interface. The system performs an access operation to the first interface information database based on the information database association parameters and displays the access status.

10. The method according to any one of claims 1-6, further comprising: Display a first compilation result, and / or display a second compilation result; the first compilation result is displayed after the intermediate code is obtained, and the second compilation result is displayed after the second functional code is obtained.

11. An application development apparatus, comprising: A first response module is used to respond to a first trigger operation and display a first compilation interface. The first compilation interface is associated with a first software toolkit, which is integrated in a pluggable manner. The second response module is used to respond to the second trigger operation, and, in conjunction with the accessed first interface information library, compile the first function code into intermediate code, and / or compile it into second function code. The first function code is written in a first language, and the second function code is presented in a second language.

12. A computer program product comprising a computer program that, when executed by a processor, implements the application development method according to any one of claims 1-10.

Images