Method and system for software development

Abstract

Provided are a method and system for software development. The method is applied to an IDE. The IDE comprises an IDE frontend and a first IDE backend, wherein the first IDE backend supports running in a plurality of types of environments, which comprise at least one of the following: a plurality of types of operating systems or a plurality of types of hardware architectures. The method comprises: an IDE frontend acquiring configuration information from a user, wherein the configuration information comprises at least one of the following: the type of a hardware architecture or the type of an operating system (610); and the IDE frontend deploying a first IDE backend in a first environment on the basis of the configuration information, so as to implement software development on the first IDE backend in the first environment by means of the IDE frontend, wherein the first environment is an environment, which is determined on the basis of the configuration information, among a plurality of types of environments supported by the first IDE backend (620).

Description

Method and system for software development

[0001] This application claims priority to Russian Federal Patent Application No. 2024107965 filed with the Russian Federal Intellectual Property Office on March 27, 2024, and priority to Russian Federal Patent Application entitled “Method and system for software development”, the entire contents of which are incorporated herein by reference. Technical Field

[0002] The present application relates to the field of computer technology, and more specifically, to a method and system for software development. Background Art

[0003] With the advancement of information technology, software development scenarios are becoming increasingly diverse. For example, software development may involve multiple programming languages, operating systems, or hardware architectures. These different development scenarios require different compilation chains (or development environments). This leads to increasingly stringent requirements for development environments and tools.

[0004] An integrated development environment (IDE) is an application program that provides a program development environment. Different IDE versions have different support for development scenarios. For example, the software development process may require the use of multiple programming languages, and different programming languages ​​may need to be supported by different IDE versions. In this case, the user needs to select multiple versions of the IDE to support the corresponding programming languages. For another example, the software development process may involve different operating systems, and the IDE version is usually bound to the operating system and chip architecture. In this case, the user needs to select multiple versions of the IDE to support software development in the corresponding operating system. In the above process, when developing software, the user needs to configure a variety of hardware and / or software according to the development scenario, and also needs to manage the software development processes in different IDEs. This makes it difficult for users to focus on the implementation of the business logic of software development, seriously affecting the user's development efficiency, thereby affecting the user's development experience. Summary of the Invention

[0005] This application provides a method and system for software development, which is conducive to improving the user's development experience.

[0006] In a first aspect, a method for software development is provided, which is applied to an integrated development environment (IDE), wherein the IDE includes an IDE front end and a first IDE back end, wherein the first IDE back end supports running in multiple types of environments, wherein the multiple types of environments include at least one of the following: multiple types of operating systems or multiple types of hardware architectures. The method includes: the IDE front end obtains user configuration information, wherein the configuration information includes at least one of the following: the type of hardware architecture or the type of operating system; the IDE front end deploys the first IDE back end in a first environment according to the configuration information, so that software development is implemented on the first IDE back end in the first environment through the IDE front end, wherein the first environment is an environment determined according to the configuration information among the multiple types of environments supported by the first IDE back end.

[0007] According to the solution of the embodiment of the present application, the IDE is divided into an IDE front-end and an IDE back-end (such as a first IDE back-end). The specific operations of software development can be completed by the first IDE back-end. The same IDE back-end supports running in various types of environments, which is conducive to supporting a variety of development scenarios and improving the flexibility of the development model. In this way, users can select appropriate development scenarios, appropriate hardware architectures, and operating systems as needed to carry out software development without having to consider IDE version issues or configure and install the development environment by themselves. This allows users to focus on the business logic of software development itself, which is conducive to improving development efficiency, thereby improving the user's development experience.

[0008] Exemplarily, the IDE front end may be deployed in a local system.

[0009] For example, the number of the first IDE backends may be one or more, that is, the IDE front end may interact with one IDE back end or with multiple IDE back ends.

[0010] The first environment may include any one or more of the following: a local container, a local virtual machine, a remote container, or a remote virtual machine.

[0011] In combination with the first aspect, in certain implementations of the first aspect, the IDE front end runs on a client program of the IDE or a client program of a browser.

[0012] According to the solution of the embodiment of the present application, the IDE front end can be deployed in the client program of the IDE or in the client program of the browser, providing users with a variety of options, further improving the flexibility of the development mode, and helping to further improve development efficiency, thereby further improving the user's development experience.

[0013] In combination with the first aspect, in certain implementations of the first aspect, the IDE front end includes a user interface UI component and an adaptation layer, the UI component is used to provide a user interface, and the adaptation layer is used to provide a unified interface for the UI component so that the UI component can run in one or more client programs.

[0014] According to the solution of the embodiment of the present application, the adaptation layer can provide a unified interface for UI components, shielding the differences between the API interfaces of different client programs, so as to realize the interaction between UI components and the desktop application framework layer. In this way, the front-end UI running in different client programs / frameworks can be implemented by the same set of UI component code. In other words, the front-end UI can support the same set of UI component code through cross-platform desktop framework adaptation, so that it can run in multiple client programs and / or frameworks.

[0015] In combination with the first aspect, in some implementations of the first aspect, the first IDE backend includes an IDE kernel, which is used to provide language features of multiple programming languages.

[0016] Exemplarily, the language features may include any one or more of the following: code completion, browsing, jumping, checking, compiling and building, testing, debugging, or refactoring.

[0017] According to the solution of the embodiment of the present application, the IDE backend can use a unified IDE core, and the same IDE core can support multiple programming languages. In this way, users can choose the appropriate programming language for software development according to their needs without having to consider the IDE version. This further increases the flexibility of the development model, helps to further improve development efficiency, and thus further enhances the user's development experience.

[0018] In combination with the first aspect, in certain implementations of the first aspect, the IDE kernel includes: an index system for storing index information of the source code, a language parsing adaptation layer for calling a language parser corresponding to the programming language of the source code to parse the source code, and a language feature layer for providing language features of multiple programming languages, including the programming language of the source code.

[0019] According to the solution of the embodiment of the present application, the IDE backend can adopt a unified IDE kernel, which includes a language-related layer and a language-independent layer. The language-related layer, that is, the language feature layer, can provide language features of multiple programming languages. The indexing system and language parsing adaptation layer in the language-independent layer are language-independent and can be applied to the language features of all programming languages. This enables the same IDE kernel to support multiple programming languages.

[0020] In combination with the first aspect, in certain implementations of the first aspect, the multiple types of environments include a local system where the IDE front end is located and / or other environments outside the local system.

[0021] In conjunction with the first aspect, in certain implementations of the first aspect, a first environment includes one or more instances, and the IDE front-end deploys a first IDE back-end on the first environment based on configuration information, including: the IDE front-end obtains one or more instances based on the configuration information, the first IDE back-end being deployed in one or more instances; or, the IDE front-end obtains one or more instances based on the configuration information; and if the first IDE back-end is not deployed in some or all of the one or more instances, the IDE front-end deploys the first IDE back-end in the instances where the first IDE back-end is not deployed. In conjunction with the first aspect, in certain implementations of the first aspect, the method further includes: the IDE front-end starts the first IDE back-end in a first instance of the one or more instances, so that the first IDE back-end in the first instance provides language features of a first programming language supported by the first instance.

[0022] In combination with the first aspect, in some implementations of the first aspect, the method further includes: the IDE front end establishes a persistent connection with the first IDE back end in the first instance.

[0023] In this way, the first IDE backend in the first instance can be in a standby state at any time, thereby improving the efficiency of interaction.

[0024] In combination with the first aspect, in certain implementations of the first aspect, the IDE front end starts the first IDE back end in the first instance of one or more instances, including: the IDE front end starts the first IDE back end in the first instance according to a first operation, and the first operation indicates a first programming language.

[0025] In combination with the first aspect, in some implementations of the first aspect, the first operation includes an operation of opening a first code file, and the first programming language is a programming language of the first code file.

[0026] In combination with the first aspect, in some implementations of the first aspect, the configuration information is indicated by a login request carrying verification information.

[0027] In combination with the first aspect, in some implementations of the first aspect, when the first IDE backend runs in an environment other than the local system, the IDE frontend and the first IDE backend communicate through a secure shell (SSH) tunnel.

[0028] In combination with the first aspect, in certain implementations of the first aspect, the method further includes: the IDE front end sends the first request to the first IDE back end in the first environment; the first IDE back end in the first environment generates a first response to the first request; and the first IDE back end in the first environment returns the first response to the IDE front end.

[0029] The IDE front end cooperates with the first IDE back end in the first environment to implement software development in the system where the first IDE back end is located.

[0030] In combination with the first aspect, in certain implementations of the first aspect, the IDE also includes a second IDE backend running in a second environment, and the method also includes: the IDE front end sends a second request to the first IDE back end in the first environment; the first IDE back end in the first environment forwards the second request to the second IDE back end in the second environment; the second IDE back end in the second environment generates a second response to the second request; the second IDE back end in the second environment sends the second response to the first IDE back end in the first environment; and the first IDE back end in the first environment returns the second response to the IDE front end.

[0031] The first IDE backend and the second IDE backend may run in different environments, that is, the types of the first environment and the second environment may be different.

[0032] The IDE front end, the first IDE back end and the second IDE back end cooperate to implement software development in the system where the second IDE back end is located.

[0033] In combination with the first aspect, in some implementations of the first aspect, the method further includes: the first IDE backend in the first environment projects the graphical user interface program running in the remote environment to the local system where the IDE front end is located through a display server protocol.

[0034] In this way, the graphical user interface of the process in the remote environment can be output to the operating system where the IDE front end is located.

[0035] In a second aspect, a system for software development is provided, including: an IDE front-end and a first IDE back-end, the first IDE back-end supports running in multiple types of environments, the multiple types of environments including at least one of the following: multiple types of operating systems or multiple types of hardware architectures, the IDE front-end is used to: obtain user configuration information, the configuration information including at least one of the following: the type of hardware architecture or the type of operating system; deploy the first IDE back-end in the first environment according to the configuration information, so that software development on the first IDE back-end in the first environment is implemented through the IDE front-end, the first environment being an environment determined according to the configuration information among the multiple types of environments supported by the first IDE back-end.

[0036] According to the solution of the embodiment of the present application, the IDE is divided into an IDE front-end and an IDE back-end (such as a first IDE back-end). The specific operations of software development can be completed by the first IDE back-end. The same IDE back-end supports running in various types of environments, which is conducive to supporting a variety of development scenarios and improving the flexibility of the development model. In this way, users can select appropriate development scenarios, appropriate hardware architectures, and operating systems as needed to carry out software development without having to consider IDE version issues or configure and install the development environment by themselves. This allows users to focus on the business logic of software development itself, which is conducive to improving development efficiency, thereby improving the user's development experience.

[0037] In conjunction with the second aspect, in certain implementations of the second aspect, the IDE front end runs on a client program of the IDE or a client program of a browser.

[0038] In combination with the second aspect, in certain implementations of the second aspect, the IDE front end includes a user interface UI component and an adaptation layer, the UI component is used to provide a user interface, and the adaptation layer is used to provide a unified interface for the UI component so that the UI component can run in one or more client programs.

[0039] In conjunction with the second aspect, in some implementations of the second aspect, the first IDE backend includes an IDE kernel, which is used to provide language features of multiple programming languages.

[0040] In combination with the second aspect, in certain implementations of the second aspect, the IDE kernel includes: an index system for storing index information of the source code, a language parsing adaptation layer for calling a language parser corresponding to the programming language of the source code to parse the source code, and a language feature layer for providing language features of multiple programming languages, including the programming language of the source code.

[0041] In conjunction with the second aspect, in certain implementations of the second aspect, the multiple types of environments include a local system where the IDE front end is located and / or other environments outside the local system.

[0042] In combination with the second aspect, in certain implementations of the second aspect, the first environment includes one or more instances, and the IDE front-end is specifically used to: obtain one or more instances based on configuration information, and the first IDE back-end is deployed in one or more instances; or, obtain one or more instances based on configuration information; and if the first IDE back-end is not deployed in some or all of the one or more instances, deploy the first IDE back-end in the instances where the first IDE back-end is not deployed.

[0043] In combination with the second aspect, in certain implementations of the second aspect, the IDE front end is also used to: start the first IDE back end in the first instance of one or more instances, so that the first IDE back end in the first instance provides language features of the first programming language supported by the first instance.

[0044] In combination with the second aspect, in some implementations of the second aspect, the IDE front end is further used to: establish a persistent connection with the first IDE back end in the first instance.

[0045] In combination with the second aspect, in some implementations of the second aspect, the IDE front end is specifically used to: start the first IDE back end in the first instance according to a first operation, and the first operation indicates a first programming language.

[0046] In combination with the second aspect, in some implementations of the second aspect, the first operation includes an operation of opening a first code file, and the first programming language is a programming language of the first code file.

[0047] In combination with the second aspect, in some implementations of the second aspect, the configuration information is indicated by a login request carrying verification information.

[0048] In combination with the second aspect, in certain implementations of the second aspect, the IDE front end is also used to: send a first request to a first IDE back end in the first environment; and the first IDE back end in the first environment is used to: generate a first response to the first request; and return the first response to the IDE front end.

[0049] In combination with the second aspect, in certain implementations of the second aspect, the system also includes a second IDE backend running in the second environment, and the IDE front end is further used to: send the second request to the first IDE back end in the first environment; the first IDE back end in the first environment is used to forward the second request to the second IDE back end in the second environment; the second IDE back end in the second environment is used to: generate a second response to the second request; send the second response to the first IDE back end in the first environment; and the first IDE back end in the first environment is further used to: return the second response to the IDE front end.

[0050] In combination with the second aspect, in some implementations of the second aspect, the first IDE backend in the first environment is further used to project the graphical user interface program running in the remote environment to the local system where the IDE frontend is located through a display server protocol.

[0051] It should be understood that the expansion, limitation, explanation and description of the relevant content in the above-mentioned first aspect also apply to the same content in the second aspect.

[0052] In a third aspect, a computing device cluster is provided, comprising at least one computing device, each computing device including a processor and a memory. The processor of the at least one computing device is configured to execute instructions stored in the memory of the at least one computing device, so that the computing device cluster performs the method of the first aspect or any implementation of the first aspect.

[0053] In a fourth aspect, a computer-readable medium is provided, comprising computer program instructions. When the computer program instructions are executed by a computing device cluster, the computing device cluster executes the method in the first aspect or any one of the implementations of the first aspect.

[0054] In a fifth aspect, a computer program product comprising instructions is provided. When the instructions are executed by a computing device cluster, the computing device cluster executes the method in the first aspect or any one of the implementations of the first aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] FIG1 is a schematic structural diagram of the architecture of a heterogeneous operating system.

[0056] FIG2 is a schematic structural diagram of an IDE architecture according to an embodiment of the present application.

[0057] FIG3 is a schematic structural diagram of a cross-platform desktop framework according to an embodiment of the present application.

[0058] FIG4 is a schematic structural diagram of another IDE architecture according to an embodiment of the present application.

[0059] FIG5 is a schematic structural diagram of an IDE kernel according to an embodiment of the present application.

[0060] FIG6 is a schematic structural diagram of another IDE architecture according to an embodiment of the present application.

[0061] FIG7 is a schematic diagram of an application projection according to an embodiment of the present application.

[0062] FIG8 is a schematic diagram of application projection in two scenarios according to an embodiment of the present application.

[0063] FIG9 is a schematic flowchart of a method for software development according to an embodiment of the present application.

[0064] FIG10 is a schematic diagram of an embodiment of the present application in which the solution is applied to a local IDE development scenario.

[0065] FIG11 is a schematic diagram of an embodiment of the present application in which the solution is applied to a WebIDE development scenario.

[0066] FIG12 is a schematic diagram of an embodiment of the present application in which the solution is applied to another WebIDE development scenario.

[0067] FIG13 is a schematic diagram of an embodiment of the present application in which the solution is applied to a local IDE in a remote development scenario.

[0068] FIG14 is a schematic diagram of an embodiment of the present application in which the solution is applied to a WebIDE in a remote development scenario.

[0069] FIG15 is a schematic diagram of an embodiment of the present application in which the solution is applied to a local IDE development scenario.

[0070] FIG16 is a schematic diagram of an embodiment of the present application in which the solution is applied to a WebIDE development scenario.

[0071] FIG17 is a schematic diagram of an embodiment of the present application in which the solution of a local IDE is applied to a development scenario of remote development.

[0072] FIG18 is a flowchart of another method for software development according to an embodiment of the present application.

[0073] FIG19 is a schematic block diagram of a system for software development according to an embodiment of the present application.

[0074] Figure 20 is a schematic block diagram of a computing device according to an embodiment of the present application.

[0075] FIG21 is a schematic block diagram of a computing device cluster according to an embodiment of the present application.

[0076] FIG22 is a schematic block diagram of another computing device cluster according to an embodiment of the present application. DETAILED DESCRIPTION

[0077] The technical solution in this application will be described below with reference to the accompanying drawings.

[0078] The terms used in the following embodiments are for the purpose of describing specific embodiments only and are not intended to limit the present application. As used in the specification and appended claims of this application, the singular expressions "a," "an," and "the" are intended to include expressions such as "one or more," unless the context clearly indicates otherwise. It should also be understood that in the following embodiments of this application, "at least one," "at least one," and "one or more" refer to one, two, or more. "First," "second," and various numerical designations are merely distinctions made for ease of description and are not intended to limit the scope of the embodiments of this application. "And / or" is used to describe the corresponding relationship between corresponding objects, indicating that three relationships can exist. For example, "A and / or B" can mean: only A exists, only B exists, and both A and B exist, where A and B can be singular or plural. The character " / " generally indicates that the objects associated with each other are in an "or" relationship. The order of the sequence numbers of the processes below does not imply a sequence of execution. The execution order of each process should be determined by its function and inherent logic and should not constitute any limitation on the implementation process of the embodiments of this application. For example, in the embodiments of the present application, words such as "301", "401", and "501" are merely identifiers for the convenience of description and do not limit the order of executing the steps.

[0079] References to "one embodiment" or "some embodiments" in this specification mean that one or more embodiments of the present application include specific features, structures or characteristics described in conjunction with the embodiment. In this application, words such as "exemplary" or "for example" are used to indicate examples, illustrations or explanations. Any embodiment or design described in this application as "exemplary" or "for example" should not be interpreted as being more preferred or more advantageous than other embodiments or design. Specifically, the use of words such as "exemplary" or "for example" is intended to present the relevant concepts in a concrete way. The terms "including", "comprising", "having" and their variations all mean "including but not limited to", unless otherwise specifically emphasized. In the embodiments of the present application, descriptions such as "when...", "in the case of...", "if" and "if" all mean that the device will perform corresponding processing under certain objective circumstances, and do not limit the time, nor do they require the device to perform judgment actions when implemented, nor do they mean that there are other limitations.

[0080] In this application, "used to indicate" can include being used for direct indication and being used for indirect indication. When describing that a certain indication information is used to indicate A, it can include that the indication information directly indicates A or indirectly indicates A, and it does not mean that the indication information must carry A.

[0081] In order to help those skilled in the art better understand the technical solutions of the present application, some terms that may be involved in the embodiments of the present application are explained below.

[0082] 1. Integrated development environment (IDE):

[0083] IDE is an application used to provide a program development environment, generally including tools such as code editors, compilers, debuggers, and graphical user interfaces. It is an integrated development software service suite that integrates code writing, analysis, compilation, debugging, and other functions.

[0084] IDEs may include local IDEs and web IDEs.

[0085] A local IDE, also known as a desktop IDE, is installed on the user's local device. This means that developers can install the development environment on their local device. For example, the local device can be a terminal device, such as a desktop computer, laptop, or mobile phone.

[0086] A Web IDE is an online IDE, or integrated development environment, for developers. It consists of an IDE front-end and an IDE back-end. The front-end runs in a browser, while the back-end can run in a remote environment, such as a cloud server. This allows programmers to develop software simply by opening a browser, without having to install the development environment locally. Web IDEs also support features like breakpoint debugging, version management, and team development.

[0087] 2. Heterogeneous systems:

[0088] A heterogeneous system is one composed of different types of hardware or software. These components can be heterogeneous. Each component of a heterogeneous system has its own autonomy, retaining its own application characteristics, integrity, and security features while enabling data sharing.

[0089] Heterogeneous operating systems (OS) can include multiple heterogeneous operating systems, such as Hongmeng OS and Euler OS. Some operating systems can run on different hardware architectures. Hardware architecture can also be called processor architecture, chip architecture or hardware platform. Different hardware architectures can also be replaced by different processor architectures, different chip architectures, different hardware platforms, different processor types, different hardware types, different chip types or different central processing units (CPUs). Taking Hongmeng OS and Euler OS as examples, the hardware architectures that these systems can be compatible with include but are not limited to: Kunpeng, X86 and ARM. The design and implementation of heterogeneous operating systems have high performance, scalability and flexibility.

[0090] Figure 1 shows a schematic structural diagram of a heterogeneous operating system architecture. As shown in Figure 1, the heterogeneous operating system architecture may include a user interaction layer, an application layer, a system service layer, a heterogeneous operating system kernel subsystem, and a hardware platform.

[0091] The user interaction layer is used to provide a human-computer interaction interface, such as a graphical user interface (GUI) or a command-line interface (CLI).

[0092] The application layer is used to provide a multi-language user program framework for applications, as well as a multi-language framework application programming interface (API) for various software and hardware services to be open to the outside world; it also provides a multi-language framework API for devices that use the system.

[0093] The system service layer includes one or more of the following services: basic system capabilities, basic software services, enhanced software services or hardware services, etc., which provide basic capabilities for the operation, scheduling, migration and other operations of distributed applications on multiple devices in the system. It can include any one or more of the following subsystems: distributed soft bus, distributed data management, distributed task scheduling, multi-language runtime, public basic library, multi-mode input, graphics, security or AI subsystems.

[0094] The heterogeneous operating system kernel subsystem is used to shield the differences between multiple kernels and provide basic kernel capabilities to the upper layer. This can include any one or more of the following: process / thread management, memory management, file system, network management, or peripheral management. It can also provide unified peripheral access capabilities and a driver development and management framework for the hardware ecosystem.

[0095] As shown in Figure 1, containers based on different operating systems can be created in the system, such as container #1, container #2, and container #3. Container #1 is based on OS #A, and container #2 is based on OS #B. OS #A and OS #B are different operating systems.

[0096] Exemplarily, the hardware platform in FIG1 may include any one of Kunpeng, X86 or ARM.

[0097] With the advancement of information technology, software development scenarios are becoming increasingly diverse, placing increasing demands on development environments and tools. Different IDE versions vary in their support for development scenarios. Users must configure and create a suitable development environment based on their specific scenarios before they can begin software development.

[0098] Taking operating systems and hardware architectures as an example, IDE versions are typically tied to these operating systems and hardware architectures. In other words, an IDE product has multiple versions, and each version can only run on a specific operating system and hardware architecture. For example, an IDE includes four versions: version #1, version #2, version #3, and version #4. These four versions run in the following scenarios: OS #1 + hardware type #1, OS #1 + hardware type #2, OS #2 + hardware type #3, and OS #2 + hardware type #4. If a user needs to develop software on a specific hardware architecture, they need to install the corresponding IDE version and create the corresponding development environment. For example, if a user needs to develop software based on hardware type #1, they need to install the IDE version that supports hardware type #1, namely version #1.

[0099] Taking remote development as an example, users enable remote development in desktop applications and configure the remote development environment based on the development scenario. Specifically, the following steps may be included:

[0100] 1) The IDE front-end is connected to the remote server via SSH. The user must ensure that the operating system to be developed has been installed on the remote server.

[0101] For example, if you need to develop an application program for operating system #1, you need to ensure that operating system #1 has been installed on the remote server.

[0102] 2) Configure the development environment.

[0103] Users need to select the appropriate IDE version based on their development scenario to configure the development environment. This version of the IDE is used to run their development projects.

[0104] Specifically, users need to determine the appropriate IDE based on the programming language and chip architecture.

[0105] 3) Create a development environment.

[0106] After the user selects, the system will download the corresponding IDE backend to the remote server to create a remote development environment. That is, the development environment runs as the IDE backend.

[0107] 4) Connect to the development environment.

[0108] That is, the connection between the IDE front-end and the IDE back-end. After that, users can perform remote development.

[0109] As can be seen from the above solutions, when developing software in different development scenarios, users need to select the appropriate hardware, software, and IDE version based on the specific development scenario. Accordingly, users may need to configure and / or install multiple hardware and software. In addition, users need to manage the software development process in different IDEs. This distracts users from focusing on software development, seriously affecting development efficiency and the user development experience.

[0110] In view of this, the embodiments of the present application provide a system architecture for software development that can support multiple development scenarios, such as multiple programming languages, multiple operating systems, multiple hardware architectures, and multiple development modes, which is conducive to ensuring user development efficiency and improving user development experience.

[0111] In the embodiment of the present application, the system architecture for software development can also be called IDE architecture. The IDE architecture in the embodiment of the present application can be called a "one-core, multi-mode" architecture, that is, the same IDE core can support multiple development scenarios.

[0112] Exemplarily, the multiple operating systems may include any one or more of the following: Euler operating system, Hongmeng operating system, or other operating systems. For example, the other operating system may be Xinchuang operating system.

[0113] Exemplarily, the multiple hardware architectures may include any one or more of the following: Kunpeng, X86, or ARM, etc.

[0114] The detailed description of various development modes can be found in the following text and will not be expanded here.

[0115] Figure 2 shows a schematic structural diagram of an IDE architecture according to an embodiment of the present application. The system architecture of the embodiment of the present application will be described below with reference to Figure 2.

[0116] 2 , the system 200 may include an IDE front-end 210 and a first IDE back-end 220. The IDE front-end 210 and the first IDE back-end 220 may communicate with each other.

[0117] The “first” in “first IDE backend” is only used to illustrate that the IDE backend can communicate with the IDE front-end to implement software development, and does not have any other limiting effect.

[0118] The front-end of IDE can also be called the front-end IDE, and the back-end of IDE can also be called the back-end IDE.

[0119] The IDE front end 210 is described below.

[0120] The IDE front end 210 can be deployed in a local operating system. In the embodiment of the present application, the local operating system can also be referred to as a local system. In a possible understanding, the operating system where the IDE front end 210 is located can be regarded as a local operating system.

[0121] The IDE front end 210 may be used to provide a user interface (UI).

[0122] In other words, the IDE front end 210 may include a front end UI. For example, the IDE front end 210 may be a lightweight front end UI deployed in a local operating system.

[0123] A user may interact with the IDE front end 210 .

[0124] The IDE front end 210 supports running in a variety of client programs / frameworks.

[0125] Optionally, the IDE front end 210 can be run in a client program of the IDE. The client program of the IDE can be deployed in a local operating system.

[0126] The user can download the client program of the IDE and install it in the local operating system, and run the IDE front end 210 by running the client program of the IDE.

[0127] The client program of an IDE may also be referred to as the client program of a desktop IDE, the client program of a local IDE, or the client program of an IDE.

[0128] Optionally, the IDE front end 210 can be run in a client program of a browser. The client program of the browser can be deployed in a local operating system.

[0129] The user does not need to download the client program of the IDE and can run the IDE front end 210 in the browser.

[0130] Figure 3 shows a schematic diagram of a cross-platform desktop framework according to an embodiment of the present application. As shown in Figure 3, an IDE front end 210 is deployed in the framework.

[0131] As shown in Figure 3, the framework also includes a desktop application framework layer 310. The desktop application framework layer 310 may include one or more client programs. These one or more client programs are used to build cross-platform applications. For example, the client programs of the desktop application framework layer 310 may include any one or more of the following: a browser, Electron, Webview2, QT, or Tauri. The browser may be Chromium.

[0132] The one or more client programs may also be replaced by one or more frameworks.

[0133] Different client programs and / or frameworks may provide different application programming interfaces (APIs).

[0134] In a possible implementation, the IDE front end 210 may include a UI component 211 and an adaptation layer 212 , as shown in FIG3 .

[0135] The UI component 211 is used to provide a user interface.

[0136] Exemplarily, the UI component 211 may include any one or more of the following: a button, an input box, a menu, an editor, a window, a dialog box, or a terminal command line window, etc.

[0137] The adaptation layer 212 is used to provide a unified interface for the UI component 211 so that the UI component 212 can run in one or more client programs.

[0138] In other words, the adaptation layer 212 is used to provide a unified interface for the UI component 211 to implement the interaction between the UI component and the desktop application framework layer.

[0139] The adaptation layer 212 may also be referred to as a cross-platform desktop framework adaptation layer 212 .

[0140] In this way, the front-end UI running on different client programs / frameworks can be implemented by the same set of UI component code. In other words, the front-end UI can support the same set of UI component code through cross-platform desktop framework adaptation, so that it can run on multiple client programs and / or frameworks.

[0141] The adaptation layer 212 can shield the differences between different APIs for the UI component 211 and provide a unified interface for the UI component, so that the same set of UI component codes can be adapted to multiple client programs and / or frameworks.

[0142] As shown in Figure 3, the framework may further include a basic operating environment 320 and an operating system 330. The basic operating environment 320 is used to provide a software environment for running programs in corresponding programming languages.

[0143] Exemplarily, the basic operating environment 320 may include any one or more of the following: Node JS, Python operating environment, Java operating environment, or a low level virtual machine (LLVM).

[0144] Exemplarily, the operating system 330 may include any one or more of the following: Hongmeng OS, Euler OS or other XC OS.

[0145] The first IDE backend 220 of the embodiment of the present application is described below.

[0146] The first IDE backend 220 may be deployed in the first environment.

[0147] The “first” in the “first environment” is only used to indicate that the environment is the environment where the first IDE backend 220 is located, and does not have any other limiting effect.

[0148] The first IDE backend 220 may include an IDE kernel, which may be configured to provide language features of one or more programming languages.

[0149] The IDE kernel may include a language-dependent layer and a language-independent layer. When the IDE kernel can be used to provide the language characteristics of multiple programming languages, the IDE kernel may also be referred to as a multi-language IDE kernel.

[0150] FIG4 shows a schematic structural diagram of another IDE architecture according to an embodiment of the present application. The solution shown in FIG4 can be regarded as two specific implementations of the solution shown in FIG2 .

[0151] As shown in Figure 4, the language-dependent layer may include a language feature layer, and the language-independent layer may include a language parsing adaptation layer and an indexing system.

[0152] The language feature layer can be used to provide language features of multiple programming languages.

[0153] Exemplarily, the multiple programming languages ​​may include any one or more of the following: python, java, C++, C#, or JavaScript, etc.

[0154] Figure 5 shows a schematic diagram of an IDE kernel according to an embodiment of the present application. For example, as shown in Figure 5 , the language feature layer of the IDE kernel includes four language features: Python language features, Java language features, C++ language features, and C# language features. It should be understood that the language features in Figure 5 are merely examples. In other implementations, the language feature layer may also provide a different number of language features and / or language features of other programming languages, and this embodiment of the present application does not limit this.

[0155] Exemplarily, the language features may include any one or more of the following: code completion, browsing, jumping, checking, compiling and building, testing, debugging, or refactoring.

[0156] The language-independent layer can be shared by all language features.

[0157] The language parsing adaptation layer can be used to call the language parser corresponding to the programming language of the source code to parse the source code to generate source code index information. The source code index information can be provided to the language features for use.

[0158] The index system can be used to store index information of source code.

[0159] The first IDE backend may also be used to provide other functions, such as storing code models or storing source codes.

[0160] Specifically, during the software development process, taking the first source code as an example, the language parsing adaptation layer can call the language parser corresponding to the programming language of the first source code to parse the first source code, thereby generating index information of the first source code for use with the language characteristics of the programming language of the first source code. The indexing system can store the index information of the first source code. The language characteristic layer can provide the language characteristics of the programming language of the first source code. In other words, the language characteristics of the programming language of the first source code in the language characteristic layer are activated, causing the language characteristic layer to provide the language characteristics of the programming language.

[0161] For example, the first source code may be the source code currently being processed, or the source code in a currently opened code file, etc.

[0162] The number of first IDE backends 220 can be one, as shown in FIG4(a), or multiple, as shown in FIG4(b). In other words, the IDE front end can establish a connection with one first IDE backend 220, or multiple first IDE backends 220. In other words, the IDE front end can interact with one first IDE backend 220, or multiple first IDE backends 220.

[0163] The differences among the multiple IDE backends 220 may include any one or more of the following: operating system, hardware architecture, or programming language.

[0164] For example, a user may need to develop a multi-language project, i.e., a project involving multiple programming languages. In this case, each programming language may be provided with corresponding services by a first IDE backend 220.

[0165] Taking two programming languages ​​(e.g., Python and Java) as an example, the IDE front-end can interact with two first IDE back-ends 220. For example, the IDE kernels of the two first IDE back-ends 220 can be the IDE kernel shown in FIG5 . When a user operates on a Python file, the language feature layer of one of the first IDE back-ends 220 provides Python language features. When a user operates on a Java file, the language feature layer of the other first IDE back-end 220 provides Java language features.

[0166] In the embodiments of the present application, the IDE kernel can support multiple programming languages, that is, it can provide corresponding language services for multiple programming languages. When it is necessary to provide corresponding language services for different programming languages, the same IDE kernel can be used to implement them. This eliminates the need for users to select the corresponding IDE version based on the programming language, which helps to simplify user experience and improve the user experience.

[0167] The first IDE backend 220 supports running in multiple types of environments. That is, the first environment can be of multiple types.

[0168] The multiple types of environments include at least one of the following: multiple types of operating systems or multiple types of hardware architectures.

[0169] That is, the same IDE backend can be deployed in different operating systems or different hardware architectures. That is, the first IDE backend 220 can support running in multiple types of operating systems. The first IDE backend can support running on multiple types of hardware architectures.

[0170] In other words, the deployment environment of the first IDE backend 220 is a configurable item. For example, the user can configure one or more hardware architecture types and / or one or more operating system types, and the same first IDE backend 220 can be deployed in each user-configured environment.

[0171] For example, using operating systems as an example, corresponding runtimes are provided for different operating systems, allowing the first IDE backend 220 to run on different operating systems. For example, taking Java as the programming language and Euler OS as the operating system, the operating system of the first environment can be Euler OS, and the first environment provides a Java runtime. In this way, the first IDE backend 220 can run on the first environment.

[0172] The following is an illustrative description of different division methods.

[0173] The first environment can be a local system or a remote environment, that is, the first IDE backend 220 can be deployed in a local system or a remote environment.

[0174] The first environment is a local system, which means that the IDE front end 210 and the first IDE back end 220 run in the same local system, or in other words, in the same operating system. In a possible understanding, other environments other than the local system where the IDE front end 210 is located can be regarded as remote environments.

[0175] Taking the first environment as a remote environment as an example, the IDE front-end 210 can also be used to establish a connection with the first environment. If the first IDE back-end 220 has already been deployed in the first environment, the IDE front-end 210 can be used to start the first IDE back-end 220. If the first IDE back-end 220 has not been deployed in the first environment, the IDE front-end 210 can deploy the first IDE back-end 220 in the first environment and start the first IDE back-end 220. For a detailed description, please refer to method 600 below and will not be described in detail here.

[0176] The system to which the first environment belongs can be a homogeneous system or a heterogeneous system. In the embodiments of the present application, a homogeneous system can also be understood as a homogeneous operating system, that is, the operating systems in the homogeneous system are all of the same type. A heterogeneous system can also be understood as a heterogeneous operating system, that is, a heterogeneous system includes multiple types of operating systems.

[0177] The first environment may include local computing resources or remote computing resources.

[0178] That is, the first IDE backend 220 can be deployed in a local computing resource or a remote computing resource.

[0179] Exemplarily, the computing resources may include containers and / or virtual machines. For example, the first IDE backend 220 may be deployed in any of the following: a local container, a local virtual machine, a remote container, or a remote virtual machine.

[0180] The above is merely an example and does not limit the solutions of the embodiments of the present application. In a specific implementation, the first IDE backend 220 can be deployed as needed. For example, the deployment environment of the first IDE backend 220 can be specified by the user, that is, the first IDE backend 220 can be deployed in the environment specified by the user.

[0181] As mentioned above, there may be one or more first IDE backends 220. When there are more than one first IDE backends 220, the types of deployment environments of the multiple first IDE backends 220 may be the same or different.

[0182] In the solution of the embodiment of the present application, the first IDE backend can support multiple types of environments, that is, it can run in different types of environments. In this way, users do not need to select the corresponding IDE version according to the development scenario, which helps to simplify the user's use and thus improve the user experience.

[0183] Furthermore, the first IDE backend 220 may further include a backend service proxy. The backend service proxy may be used to forward the request of the IDE frontend 210 to the IDE kernel for processing, and then return the response to the IDE frontend 210.

[0184] The following uses two methods (method #1 and method #2) as examples to illustrate the software development process.

[0185] Method #1:

[0186] In a possible implementation, the IDE front-end 210 and the first IDE back-end 220 cooperate with each other to complete software development.

[0187] In approach #1, the first IDE backend 220 can complete software development related operations, or in other words, the IDE frontend 210 and the first IDE backend 220 cooperate to implement software development in the system where the first IDE backend 220 is located.

[0188] Optionally, the IDE front end 210 may be configured to send the first request to the first IDE back end 220 .

[0189] The first IDE backend 220 may be configured to generate a first response to the first request, and return the first response to the IDE frontend 210 .

[0190] The "first" in "first request" is only used to indicate that the request is processed by the first IDE backend 220 and has no other limiting effect. The "first response" is the response to the "first request" and has no other limiting effect.

[0191] In this development scenario, the IDE front-end 210 sends the request to the first IDE back-end 220 for processing. The first IDE back-end 220 can return a response to the request to the IDE front-end.

[0192] For example, the request sent by the IDE front-end 210 may be generated based on a user operation. In other words, the IDE front-end 210 sends the user operation in the form of a request to the first IDE back-end 220. The first IDE back-end 220 may process the request and return the processing result to the IDE front-end 210 in the form of a response.

[0193] Exemplarily, the user operation may be the user's code operation, or code activity, such as editing, debugging, testing, compiling, and building.

[0194] For example, the user's code operation may be an "edit" operation. The IDE front end 210 sends the "edit" request to the first IDE back end 220. The IDE kernel in the first IDE back end 220 can process the request, give corresponding operations or instructions, etc., and return it to the IDE front end 210.

[0195] For specific examples of development scenarios under method #1, please refer to Figures 10 and 11 below.

[0196] Method #2:

[0197] FIG6 shows a schematic diagram of another IDE architecture according to an embodiment of the present application.

[0198] In another possible implementation, the system 200 may further include a second IDE backend 230, as shown in Figure 6. The IDE frontend 210, the first IDE backend 220, and the second IDE backend 230 cooperate with each other to complete software development.

[0199] The second IDE backend 230 may be deployed in a second environment, which may be a remote environment.

[0200] The first environment and the second environment can be different types of environments. The "second" in the "second environment" is only used to distinguish it from the environment where the first IDE backend 220 is located, and has no other limiting function.

[0201] The system to which the second environment belongs may be a homogeneous system or a heterogeneous system.

[0202] In method #2, the second IDE backend 230 can complete software development related operations, or in other words, the IDE frontend 210, the first IDE backend 220 and the second IDE backend 230 cooperate to implement software development in the system where the second IDE backend 230 is located.

[0203] In one possible understanding, the difference between the first IDE backend 220 and the second IDE backend 230 is that the first IDE backend 220 does not need to be forwarded by other IDE backends to communicate with the IDE frontend, while the second IDE backend 230 does need to be forwarded by other IDE backends to communicate with the IDE frontend. The "second" in "second IDE backend" is merely used to indicate that the IDE backend needs to be forwarded by other IDE backends to communicate with the IDE frontend and does not have any other limiting effect.

[0204] The second IDE backend 230 includes a language-dependent layer and a language-independent layer. The above description of the first IDE backend 220 is also applicable to the second IDE backend 230 and will not be repeated here.

[0205] A connection may be established between the first environment and the second environment, so that the IDE front-end 210 and the second IDE back-end 230 can communicate with each other through forwarding by the first IDE back-end 210 .

[0206] Optionally, the IDE front end 210 may be configured to send the second request to the second IDE back end 230 via the first IDE back end 220. The second IDE back end 230 may be configured to generate a second response to the second request, and the second response may be returned to the IDE front end 210 via the first IDE back end 220.

[0207] The "second" in "second request" is only used to indicate that the request is processed by the second IDE backend 230 and has no other limiting effect. The "second response" is the response to the "second request" and has no other limiting effect.

[0208] In this development scenario, the request sent by the IDE front end 210 is forwarded to the second IDE back end 230 via the first IDE back end 220 for processing, and the second IDE back end 230 returns the response to the request to the IDE front end 210 via the first IDE back end 220 .

[0209] For other descriptions, please refer to the previous text and will not be repeated here.

[0210] For specific examples of development scenarios under method #2, please refer to Figures 13 and 14 below.

[0211] In the solution of the embodiment of the present application, the IDE is divided into an IDE front-end and an IDE back-end. The IDE front-end is used to provide a user interface, and the specific operations of software development can be completed by the IDE back-end. The same IDE back-end supports running in various types of environments, which is conducive to supporting a variety of development scenarios and improving the flexibility of the development model. In this way, users can choose the appropriate development scenario, appropriate hardware architecture, and operating system according to their needs to carry out software development without having to consider the IDE version issue or configure and install the development environment by themselves. This allows users to focus on the business logic of software development itself, which is conducive to improving development efficiency and thus improving the user's development experience.

[0212] In addition, in the embodiment of the present application, the IDE front end can be deployed in the IDE client program or in the browser client program, providing users with a variety of options, further improving the flexibility of the development mode, and helping to further improve development efficiency, thereby further improving the user's development experience.

[0213] Furthermore, in the embodiments of the present application, the IDE backend can utilize a unified IDE kernel, which can support multiple programming languages. This allows users to select the appropriate programming language for software development as needed, without having to consider IDE versions. This further increases the flexibility of the development model, helps improve development efficiency, and thus enhances the user's development experience.

[0214] The IDE backend can adopt a unified IDE kernel, which includes a language-related layer and a language-independent layer. The language-related layer, that is, the language feature layer, can provide language features of multiple programming languages. The indexing system and language parsing adaptation layer in the language-independent layer are language-independent and can be applied to the language features of all programming languages. This allows the same IDE kernel to support multiple programming languages.

[0215] In the embodiments of this application, the IDE front-end deployment environment, the IDE back-end deployment environment, and the programming language are all configurable. This IDE architecture supports a variety of development scenarios and programming languages, greatly improving the flexibility and scalability of software development. Users can flexibly select the appropriate development scenario and programming language based on their needs without having to worry about the deployment of the development environment, which is conducive to improving the user's development experience.

[0216] Furthermore, the first IDE backend 220 may also be used for application projection.

[0217] Optionally, the first IDE backend 220 can also be used to project the GUI program in the third environment to the operating system (such as the local system) where the IDE frontend 210 is located through a display server protocol. The third environment is a remote environment.

[0218] The GUI program is projected onto the operating system where the IDE front end 210 is located, that is, the UI of the GUI program is sent to the operating system.

[0219] Application projection can be initiated by the user. For example, the user can connect to the remote environment through an IDE client or a browser client and launch the GUI program in the remote environment through a command line. The first IDE backend 220 can act as a proxy to send the GUI program's UI to the IDE client or the browser client via a display server protocol.

[0220] The number of third environments can be one or more. The number of GUI programs in a third environment can be one or more. For example, the first IDE backend 220 can be used to project one or more GUI programs in a remote environment to the operating system (such as the local system) where the IDE front end 210 is located via a display server protocol. For another example, the first IDE backend 220 can be used to project multiple GUI programs in multiple remote environments to the operating system (such as the local system) where the IDE front end 210 is located via a display server protocol.

[0221] The "third" in "third environment" is only used to describe the environment where the GUI program is located and has no other limiting effect.

[0222] The third environment can be a homogeneous system or a heterogeneous system.

[0223] When the first IDE backend 220 runs in a remote environment, the GUI program can be a GUI program running in the environment where the first IDE backend 220 is located, or a GUI program running in another environment. This embodiment of the present application is not limited to this. For example, the display server protocol can include any of the following: X, Wayland, or Remote Desktop Protocol (RDP). For example, the X protocol can be the X11 protocol, which is the 11th version of the X protocol.

[0224] Specifically, the GUI program in the remote environment can be projected into the operating system where the IDE front end 210 is located through SSH and the display server protocol.

[0225] Taking the X protocol as an example, the X protocol can include an X server and an X client. The X server is used to display the screen and notify the X client of input actions. The X client is responsible for processing program logic. The X client is a GUI program. The X server is deployed in the IDE front-end 210. The X-Server can run in an independent process, independent of the projected GUI program. The GUI program can be projected to the local system through SSH X11 forwarding, as shown in Figure 8. The GUI program in the local system in Figure 8 is the projected GUI program.

[0226] This allows the graphical user interface of the process in the remote environment to be output to the operating system where the IDE front-end is located.

[0227] Figure 7 shows a schematic diagram of an application projection according to an embodiment of the present application. As shown in Figure 7, the solution of the embodiment of the present application can realize application projection, that is, projecting a GUI program in a remote environment into a local system (ie, a local operating system).

[0228] For example, a GUI program in a remote environment may be projected into a local system via SSH and a display server protocol.

[0229] The remote environment can be a homogeneous system or a heterogeneous system.

[0230] As mentioned above, in some implementations, the first IDE backend 220 can be deployed in a remote environment. In this case, the remote environment where the GUI program is located and the remote environment where the first IDE backend 220 is located can be the same remote environment or different remote environments.

[0231] FIG8 shows schematic diagrams of application projection in two scenarios.

[0232] In FIG8 (a), the first and third environments are the same environment, i.e., the first IDE backend 220 and the GUI program are deployed in the same environment. In FIG8 (b), the first and third environments are different environments, i.e., the first IDE backend 220 and the GUI program are deployed in different environments. The two environments can communicate with each other to implement application projection.

[0233] Taking (a) of FIG8 as an example, the backend service proxy can forward the request of the IDE frontend 210 to the IDE kernel in the first IDE backend 220 for processing, and then return its response to the IDE frontend 210. The backend service proxy can also send the UI of the GUI program to the local system through the display server protocol.

[0234] It should be understood that FIG8 is merely an example and does not limit the embodiments of the present application. For example, FIG8 only uses one GUI program projected in one remote environment as an example. In other implementations, other numbers of GUI programs may be projected, and the number of remote environments in which the GUI programs reside may also be other.

[0235] The IDE frontend and backend can communicate in a variety of ways. The communication method between the IDE frontend and backend depends on the specific development model. Detailed descriptions are provided later in this article and are not detailed here.

[0236] FIG9 is a schematic flow chart of a method for software development according to an embodiment of the present application. Method 600 shown in FIG9 can be executed by system 200 shown in FIG2 . The IDE front end in method 600 can be IDE front end 210 in FIG2 . The first IDE back end in method 600 can be first IDE back end 220 in FIG2 . For a detailed description, reference can be made to first IDE back end 220.

[0237] As shown in FIG9 , method 600 includes the following steps.

[0238] 610. The IDE front end obtains user configuration information, where the configuration information includes at least one of the following: a type of hardware architecture or a type of operating system.

[0239] 620 , the IDE front end deploys the first IDE back end on the first environment according to the configuration information, so that software development on the first IDE back end in the first environment is implemented through the IDE front end.

[0240] Step 620 can also be understood as the IDE front-end deploying the first IDE back-end in the first environment according to the configuration information, so that the user can implement software development on the first IDE back-end in the first environment through interaction with the IDE front-end, or in other words, so that software development on the first IDE back-end in the first environment can be implemented through operations on the IDE front-end.

[0241] The first environment is the deployment environment of the first IDE backend. The type of the first environment is determined based on the configuration information. In other words, the type of the first environment is indicated by the configuration information. Alternatively, the first environment is determined based on the configuration information among the multiple types of environments supported by the first IDE backend.

[0242] As previously mentioned, the deployment environment of the first IDE backend is a configurable item. In step 610, relevant configuration information of the deployment environment can be obtained to determine the deployment environment of the first IDE backend. The first IDE backend is then deployed in an environment (e.g., the first environment) that meets the configuration information.

[0243] The configuration information may include one or more hardware architecture types and / or one or more operating system types. The embodiment of the present application does not limit the number of types of configured environments.

[0244] In this embodiment of the present application, the first IDE backend supports deployment in a variety of environments. For ease of description, the following description of method 600 primarily uses the deployment of the first IDE backend in a remote environment as an example. The first IDE backend deployment solution in other environments can be modified as needed. The first IDE backend can also be replaced with a first IDE backend service.

[0245] Furthermore, the method 600 may further include step 611 (not shown in the figure).

[0246] 611. The IDE front end obtains the first environment according to the configuration information.

[0247] In step 611 , the deployment environment of the first IDE backend may be obtained, that is, the environment required by the program to be developed.

[0248] The first environment may include one or more instances. The one or more instances may also be understood as one or more first environments. That is, the number of first environments may be one or more.

[0249] Step 611 can also be understood as the IDE front end obtaining one or more instances according to the configuration information. The one or more instances are used to deploy the first IDE back end.

[0250] Exemplarily, the IDE front end obtains one or more instances according to the configuration information, which may include: the IDE front end creates one or more instances according to the configuration information.

[0251] Alternatively, the IDE front-end obtaining one or more instances based on the configuration information may include: the IDE front-end determining one or more instances based on the configuration information. For example, the cloud service may provide multiple candidate instances and assign one or more instances to the IDE front-end based on the configuration information.

[0252] The acquisition of one or more instances can be triggered in a variety of ways. The following uses the creation of one or more instances as an example to illustrate.

[0253] For example, the creation of one or more instances may be triggered by starting an IDE, which may also be replaced by starting an IDE front-end.

[0254] That is, when a user starts an IDE, the creation of one or more instances is triggered. The user starting an IDE can be understood as starting the IDE in response to the user's IDE start request.

[0255] You can start the IDE front-end by launching the local IDE client program. Alternatively, you can start the IDE front-end from the browser client program.

[0256] Alternatively, the creation of one or more instances may be triggered by a user's login request, or in other words, by a user's login operation.

[0257] The login request carries verification information and can be used to request the account of the user who logged in.

[0258] For example, if one or more instances are deployed on a cloud computing service, after starting the IDE, the user can log in to their account. The IDE front-end can then connect to the cloud computing service using that account and create one or more instances on the cloud computing service.

[0259] The acquisition of one or more instances may also be triggered by other methods, which is not limited in the embodiments of the present application.

[0260] For different users, the types of instances obtained for them can be the same or different.

[0261] For example, different users can be distinguished by their account information.

[0262] Illustratively, the one or more instances may include any one or more of the following: a container or a virtual machine.

[0263] In a possible implementation, multiple instances may be obtained in step 611. In this case, the programming languages ​​corresponding to the multiple instances may be the same or different.

[0264] The programming language corresponding to an instance can be understood as the programming language supported by the instance. In other words, the instance can provide the corresponding runtime environment for the programming language. The instance can also be called an instance of the programming language.

[0265] For example, if the programming language corresponding to an instance is Java, then the instance provides a Java runtime. For another example, if the programming language corresponding to an instance is Python, then the instance provides a Python runtime.

[0266] Optionally, each of the one or more instances corresponds to a different programming language. In other words, in step 611, one or more instances of programming languages ​​may be obtained.

[0267] The one or more instances may include instances of some or all programming languages ​​supported by the first IDE backend.

[0268] The programming language supported by the first IDE backend can be understood as the language features of the programming language included in the first IDE backend.

[0269] Taking the example that the one or more instances include instances of all programming languages ​​supported by the first IDE backend, for example, the first IDE backend supports five programming languages, five instances may be created in step 620. The five instances correspond to the five programming languages ​​respectively.

[0270] The programming language corresponding to the one or more instances may be determined in various ways.

[0271] Exemplarily, the programming language corresponding to the one or more instances may be preset.

[0272] As an example, the preset programming language can be a system default programming language or a user pre-configured programming language. For example, the system default programming languages ​​include Java and Python, or the user pre-configured programming languages ​​include Java and Python. In step 611, a Java instance and a Python instance can be created.

[0273] Alternatively, the programming language corresponding to the one or more instances may be determined based on relevant information of the user.

[0274] For example, the programming language previously used by the user can be determined based on the history of the user's account, and the corresponding instance can be created.

[0275] For another example, the user's stored projects can be determined based on the user's account, and a corresponding instance can be created based on the programming language used in the project.

[0276] Alternatively, the programming language corresponding to the one or more instances may be input by a user.

[0277] For example, after starting the IDE, the user can configure the programming languages ​​needed for this software development to include Java and Python, and this configuration information can be carried in the first creation request. In step 611, a Java instance and a Python instance can be created.

[0278] The programming language corresponding to the one or more instances may be indicated by the configuration information in step 610 or by other information.

[0279] It should be understood that the above is only an example, and the specific instance of which programming language or languages ​​to create can also be determined by other means. For example, the programming language corresponding to the one or more instances can be randomly selected. This embodiment of the application does not limit this.

[0280] The type of hardware architecture of the one or more instances may be determined in a variety of ways.

[0281] In a possible implementation, multiple instances may be created in step 611. In this case, the types of hardware architectures of the multiple instances may be the same or different.

[0282] For ease of description, a hardware architecture type is used as an example below.

[0283] Exemplarily, the type of the hardware architecture of the one or more instances may be pre-set.

[0284] As an example, the pre-set hardware architecture type can be the system default hardware architecture type or the user pre-configured hardware architecture type. For example, the user pre-configures the hardware architecture type to be Kunpeng, and accordingly, the configuration information can indicate that the hardware architecture type is Kunpeng. In step 611, the one or more instances can be created on the hardware of the Kunpeng architecture.

[0285] Alternatively, the type of the hardware architecture of the one or more instances may be determined based on relevant information of the user.

[0286] For example, the type of hardware architecture previously used by the user can be determined based on the user's account history, and the corresponding instance can be created.

[0287] For another example, the user's stored projects can be determined based on the user's account, and a corresponding instance can be created based on the type of hardware architecture used by the project.

[0288] Alternatively, the type of hardware architecture of the one or more instances may be input by a user.

[0289] For example, after starting the IDE, the user can configure the type of hardware architecture required for this software development to be Kunpeng. Accordingly, the configuration information can indicate that the type of hardware architecture is Kunpeng. In step 611, the one or more instances can be created on the hardware of the Kunpeng architecture.

[0290] As described above, the type of the hardware architecture of the one or more instances can be indicated by configuration information. The form of this configuration information can be implemented in various ways. For example, for a hardware architecture type pre-configured by a user, the configuration information can be an identifier of the hardware architecture type. Alternatively, the configuration information can be an empty field. If the configuration information for the hardware architecture type is "empty," the system creates an instance according to the previously configured hardware architecture type.

[0291] It should be understood that the above is only an example, and the specific hardware architecture used can also be determined by other means. The embodiments of the present application do not limit this.

[0292] As mentioned above, multiple instances can be created in step 620. If multiple hardware architecture types are involved, instances need to be created on multiple types of hardware architectures. The method for creating instances on each hardware architecture can be referred to above. The following example illustrates this.

[0293] For example, the instances created on each of the multiple hardware architecture types may include instances of all programming languages ​​supported by the first IDE backend. For example, if the first IDE backend supports five programming languages, five instances may be created on each type of hardware architecture in step 611. The five instances correspond to the five programming languages, respectively.

[0294] Exemplarily, the programming language corresponding to the instance created on each type of hardware architecture among the multiple types of hardware architectures may be preset.

[0295] For example, the system default programming languages ​​include Java and Python, or the user pre-configures the programming languages ​​to include Java and Python. In step 611, a Java instance and a Python instance may be created on each type of hardware architecture.

[0296] Exemplarily, the programming language corresponding to the instance created on each type of hardware architecture among the multiple types of hardware architectures may be configured by a user.

[0297] For example, the user can configure the hardware architecture type required for this software development to be Kunpeng ARM, the programming language corresponding to the instance on Kunpeng is Java, and the programming language corresponding to the instance on ARM is Python. In step 611, an instance supporting Java can be created on Kunpeng, and an instance supporting Python can be created on ARM.

[0298] The above is only an example. For other implementations, please refer to the previous text and will not be repeated here.

[0299] In a possible implementation, multiple instances may be created in step 620. In this case, the operating systems of the multiple instances may be the same or different.

[0300] For ease of description, an operating system is used as an example for explanation below.

[0301] Exemplarily, the type of the operating system of the one or more instances may be preset.

[0302] As an example, the pre-set operating system type can be the system default operating system type or the user pre-configured operating system type. For example, if the user pre-configures the operating system type as Euler OS, the configuration information can accordingly indicate that the operating system type is Euler OS. In step 611, one or more instances can be created, and the operating system of each of the one or more instances can be Euler OS.

[0303] Alternatively, the type of operating system of the one or more instances may be input by a user.

[0304] For example, after starting the IDE, the user can configure the type of operating system to be used for this software development to be Euler OS. Accordingly, the configuration information can indicate that the type of operating system is Euler OS. In step 611, one or more instances can be created, and the operating system of the one or more instances can be Euler OS.

[0305] It should be understood that the above is only an example, and the type of operating system used can be determined by other means, which is not limited in the present embodiment.

[0306] As previously mentioned, multiple instances can be created in step 620. If multiple operating system types are involved, the method for creating instances based on each operating system can be referenced above. The programming languages, operating system types, and hardware architecture types corresponding to the multiple instances can be configured as needed, such as by user configuration or system default configuration.

[0307] For example, a user may need to develop applications in multiple programming languages ​​in multiple types of operating systems on multiple types of hardware architectures. In this case, multiple instances supporting the multiple programming languages ​​based on the multiple types of operating systems can be created for the user on the multiple types of hardware architectures. For a specific description, please refer to the previous text and will not be repeated here. The programming languages, operating system types, and hardware architecture types corresponding to the multiple instances can all be indicated by configuration information. The methods for obtaining configuration information for different items can be the same or different. For example, the type of operating system is indicated by the user, that is, the configuration information of the operating system is determined based on the user's input. For another example, the type of hardware architecture is the system default type, that is, the configuration information of the hardware architecture can be obtained from the system.

[0308] Optionally, the configuration information is indicated by a login request that carries verification information. For example, when logging in, a user may configure the type of hardware architecture and / or the type of operating system. The corresponding configuration information may be indicated by the login request.

[0309] The above is only an example, and the embodiment of the present application does not limit the method for obtaining configuration information.

[0310] Step 620 may include the following cases.

[0311] As described above, the IDE front end can obtain one or more instances according to the configuration information. The one or more instances may have the first IDE back end deployed or may not have the first IDE back end deployed.

[0312] If the first IDE backend has been deployed in the one or more instances, the process of obtaining the one or more instances may also be regarded as step 620 .

[0313] If the first IDE backend is not deployed in some or all of the one or more instances, step 620 may further include: deploying the first IDE backend in the instances where the first IDE backend is not deployed.

[0314] Exemplarily, the IDE front-end may send the installation package of the first IDE back-end to an instance where the first IDE back-end is not deployed, so as to implement deployment of the first IDE back-end in the corresponding instance.

[0315] Furthermore, method 600 may further include step 630 .

[0316] In step 630 , the IDE front-end starts the first IDE back-end in the first instance. The first instance belongs to the one or more instances obtained in step 611 .

[0317] After the first IDE backend in the first instance is started, it can provide language features of the first programming language supported by the first instance.

[0318] In other words, the IDE front end starts the first IDE back end in the first instance, so that the first IDE back end provides language features of the first programming language supported by the first instance.

[0319] In the embodiment of the present application, the first IDE backend can be used to provide language features of multiple programming languages. After the first IDE backend is started, the corresponding language features can be activated. Starting the first IDE backend in the corresponding instance can also be regarded as a step in activating the corresponding language service.

[0320] In one implementation, in step 630 , the first IDE backend of all instances may be started.

[0321] In another implementation, in step 630 , a first IDE backend of a specific instance (eg, the first instance) may be started.

[0322] Optionally, step 630 may include: starting a first IDE backend in the first instance according to the first operation.

[0323] The first operation may also be considered an activation operation.

[0324] In one implementation, the first operation may be an operation acting on the first item.

[0325] The first project is any software development project. The "first" in "first project" is for descriptive purposes only and does not have a limiting effect.

[0326] In a possible implementation, the first project may be a project created after the IDE is started this time.

[0327] In this case, method 600 may further include step 631 .

[0328] 631, create the first project.

[0329] Exemplarily, the first project may be created based on a project template. For example, the first project may be a multilingual project, and the user may create the first project using a corresponding multilingual project template provided by the system. The user creating the first project may be understood as creating the first project in response to a project creation request from the user, where the project creation request indicates the creation of the first project.

[0330] In another possible implementation, the first project may be a stored project opened after the IDE is started this time.

[0331] In this case, method 600 may further include step 632 .

[0332] 632, open the first project.

[0333] After starting the IDE, the user can open the first project stored previously. The user opening the first project can be understood as opening the first project in response to the user's project opening request, where the project opening request indicates opening the first project.

[0334] The language service is provided by the first IDE backend. In the embodiment of the present application, language services for different programming languages ​​are all provided by a unified first IDE backend. That is, language services for different programming languages ​​are provided by the IDE core with the same architecture. A detailed description of the first IDE backend can be found in Figure 2 and will not be repeated here.

[0335] A language service, also known as a language server, provides programming support, or in other words, supports language features such as code completion, code formatting, code diagnostics, jumps, hovering, highlighting, and type inference. The language features provided by the first IDE backend for multiple programming languages ​​can also be replaced by the language service provided by the first IDE backend for multiple programming languages.

[0336] For example, the language service may provide programming support, such as providing a set of operations or instructions, based on the current state of the IDE front end, such as the current position of the cursor in the IDE front end or the current position of the mouse hovering.

[0337] The language service of a programming language can be used to provide programming support for the programming language, that is, programming support provided when software is developed based on the programming language.

[0338] The language service and the IDE front end can communicate with each other through JavaScript (JS) object notation (JSON) remote procedure call (JSON-RPC).

[0339] The IDE front-end can notify the language service of user operations. For example, the IDE front-end can send a user's code operation to the language service in the form of a request. The language service can process the request and return the processing results to the IDE front-end in the form of a response.

[0340] In step 630, the first instance is an instance that supports the first programming language. The first IDE backend in this instance is used to provide the language service for the programming language. Step 630 can also be understood as activating the language service for the first programming language.

[0341] The first operation can be used to indicate a first programming language. For example, the first programming language can be determined by the context of the first operation.

[0342] Step 630 can also be understood as activating the corresponding language service according to the context of the first operation.

[0343] The "first" in "first operation" is only used to limit the operation to activating the first IDE backend and has no other limiting effect.

[0344] The first operation is described below by way of example, taking the first operation based on the first item as an example.

[0345] Exemplarily, the first operation on the first item may be a creation operation on the first item.

[0346] Accordingly, the first operation on the first item may be step 631 .

[0347] When the user creates the first project, the system can activate the language service of the programming language related to the first operation. For example, the system can activate the language services of all programming languages ​​in the first project.

[0348] Illustratively, the first operation on the first item may be an opening operation on the first item.

[0349] Accordingly, the first operation on the first item may be step 632 .

[0350] For example, when the user opens the first project for the first time, the system may activate the language service of the programming language associated with the first operation. For example, the system may activate the language services of all programming languages ​​in the first project.

[0351] In a possible implementation, the first operation may be an operation on a file in the first project.

[0352] Exemplarily, the first operation may be an operation of opening a first file in the first project.

[0353] For example, when the user opens the first file for the first time, the system may activate the language service of the programming language related to the first operation. The user opening the first file may be understood as opening the first file in response to the user's file open request, where the file open request indicates to open the first file.

[0354] The first file may be a code file or a non-code file.

[0355] The “first” in “first file” is used for descriptive convenience only and has no limiting effect.

[0356] Taking the first file as an example, for example, the first file is a first code file, the first operation may be an operation of opening the first code file, and the first programming language may be the programming language of the first code file. When the user first opens the first code file, the language service of the programming language used by the first code file may be activated. For example, if the first code file is a Java file, the user may activate the Java language service when opening the Java file.

[0357] For example, if the first file is a non-code file, when the user first opens the first file, the language services of all programming languages ​​in the first project can be activated. For example, the first file can be the first file opened in the first project, that is, when the user opens the first file in the first project, the language services of all programming languages ​​in the first project can be activated.

[0358] Activating the corresponding language service according to the first operation may be activating the corresponding language service immediately in response to the first operation. Alternatively, activating the corresponding language service according to the first operation may be activating the corresponding language service after a period of time in response to the first operation. This embodiment of the present application is not limited to this.

[0359] It should be understood that the above is merely an example of the first operation, and the embodiments of the present application do not limit the specific content of the first operation.

[0360] Activating the first IDE backend in the instance may include launching the first IDE backend in the instance.

[0361] During the process of activating the first IDE backend in the first instance, it may be first checked whether the first IDE backend is deployed in the first instance.

[0362] For example, the IDE front-end may check whether the first IDE back-end is deployed in the first instance.

[0363] Optionally, activating the first IDE backend in the first instance may include, if the first IDE backend is deployed in the first instance, starting the first IDE backend.

[0364] Optionally, activating the first IDE backend in the first instance may include, if the first IDE backend is not deployed in the first instance, deploying the first IDE backend in the first instance and starting the first IDE backend.

[0365] Furthermore, the method 600 may further include closing the first IDE backend according to the second operation.

[0366] In other words, stopping the first IDE backend service according to the second operation can also be understood as stopping the language service of the programming language related to the second operation.

[0367] The "second" in "second operation" is only used to limit the second operation to being related to closing the first IDE backend, and has no other limiting effect.

[0368] Specifically, which first IDE backends are closed can be set as needed. For example, the closed first IDE backend is related to the second operation.

[0369] The second operation is exemplified below.

[0370] For example, the second operation may be performed on the first item.

[0371] For example, the second operation on the first item may include a closing operation on the first item.

[0372] When the user closes the first project, the system may close the first IDE backend. For example, the system may close all started first IDE backends. The user closing the first project may be understood as closing the first project in response to the user's project close request, where the project close request indicates closing the first project.

[0373] Exemplarily, the second operation may be performed on the IDE front end.

[0374] For example, the second operation on the IDE front-end may include a closing operation on the IDE front-end.

[0375] When the user closes the IDE front end, the system can close the first IDE back end. For example, the system can close all started first IDE back ends. The user closing the IDE front end can be understood as closing the IDE front end in response to the user's IDE close request, where the IDE close request indicates that the IDE front end is closed.

[0376] Closing the first IDE backend according to the second operation may involve immediately closing the first IDE backend in response to the second operation. Alternatively, closing the first IDE backend according to the second operation may involve closing the first IDE backend after a period of time in response to the second operation. This embodiment of the present application is not limited to this.

[0377] It should be understood that the above is merely an example of the second operation, and the embodiments of the present application do not limit the specific content of the second operation.

[0378] In addition, the method 600 can be applied in a remote development scenario, that is, the first IDE backend is deployed in a remote environment.

[0379] In this case, before starting the first IDE backend in the first instance, the IDE frontend may establish a connection with the first instance. For example, the IDE frontend may establish a secure shell protocol (SSH) connection with the first instance.

[0380] In this case, activating the first IDE backend in the instance may further include establishing a long connection between the IDE frontend and the first IDE backend, so that the first IDE backend can be in a standby state at any time, thereby improving interaction efficiency.

[0381] For example, after starting the first IDE backend in the first instance, the remote port monitored by the first IDE backend can be sent to the IDE frontend. The IDE frontend can establish an SSH tunnel (local port: remote port) between the local port and the remote port and upgrade the Hypertext Transfer Protocol (HTTP) connection to a WebSocket connection. Subsequent service requests can be exchanged through this connection.

[0382] In addition, when the first IDE backend is closed, the SSH tunnel can also be closed.

[0383] In step 630, after the corresponding language service is activated, it can perform the corresponding processing. Specifically, the user's code operations, such as editing, debugging, testing, compiling, and building, can be sent by the IDE front-end to the corresponding language service in the form of requests for processing. The language service can return the processing results to the IDE front-end, which then displays the processing results to the user.

[0384] Optionally, method 600 may include: the IDE front end sends a first request to a first IDE back end in the first environment; the first IDE back end in the first environment generates a first response to the first request; and the first IDE back end in the first environment returns the first response to the IDE front end.

[0385] In this case, the IDE front-end and the first IDE back-end in the first environment cooperate to implement software development in the system where the first IDE back-end resides. That is, the specific operations of software development can be completed by the second IDE back-end. The first request can be generated based on the user's code operation.

[0386] Optionally, the IDE may further include a second IDE backend running in a second environment. In this case, the method 600 may further include:

[0387] The IDE front end sends the second request to the first IDE back end in the first environment;

[0388] The first IDE backend in the first environment forwards the second request to the second IDE backend in the second environment;

[0389] The second IDE backend in the second environment generates a second response to the second request;

[0390] The second IDE backend in the second environment sends a second response to the first IDE backend in the first environment;

[0391] The first IDE backend in the first environment returns a second response to the IDE frontend.

[0392] The IDE front-end, the first IDE back-end, and the second IDE back-end cooperate to implement software development in the system where the second IDE back-end is located. That is, the specific operations of software development can be completed by the second IDE back-end. The second request can be generated based on the user's code operation.

[0393] The description of the second IDE backend can be found in the previous article and will not be repeated here.

[0394] Furthermore, the method 600 may further include: the first IDE backend may project the graphical user interface program running in the remote environment to the local system where the IDE front end is located through a display server protocol.

[0395] The description of application projection can be found in the previous article and will not be repeated here.

[0396] Furthermore, method 600 may further include step 640 .

[0397] 640 , destroy the one or more instances.

[0398] Optionally, step 640 may include: destroying the one or more instances according to a third operation.

[0399] The "third" in "the third operation" is only used to limit the third operation to being related to instance destruction and has no other limiting effect.

[0400] The third operation is exemplarily described below.

[0401] Exemplarily, the third operation may be performed on the IDE front end.

[0402] For example, the third operation on the IDE front-end may include a closing operation on the IDE front-end.

[0403] When the user closes the IDE front-end, the system can destroy the one or more instances. For example, the system can destroy all instances related to the IDE front-end.

[0404] The third operation and the second operation may be the same operation or different operations. For example, the third operation and the second operation may be operations to close the IDE front end. That is, when the user closes the IDE front end, the system may close the first IDE back end and destroy all instances related to the IDE front end. For another example, the third operation may be an operation to close the IDE front end, and the second operation may be an operation to close the first project. That is, when the user closes the first project, the system may close the first IDE back end, and when the user closes the IDE front end, the system may destroy all instances related to the IDE front end.

[0405] It should be understood that the above is merely an example of the third operation, and the embodiments of the present application do not limit the specific content of the third operation.

[0406] Destroying the one or more instances according to the third operation may involve immediately destroying the one or more instances in response to the third operation. Alternatively, destroying the one or more instances according to the third operation may involve destroying the one or more instances after a period of time in response to the third operation. This embodiment of the present application is not limited to this.

[0407] Figures 10 to 17 illustrate schematic diagrams of the solutions of the embodiments of the present application applied in different development scenarios. The IDE architecture in Figures 10 to 17 may be the IDE architecture shown in Figure 2. A detailed description of the IDE architecture can be found in Figure 2. To avoid repetition, some descriptions of Figures 10 to 17 will be omitted. In the solutions shown in Figures 10 to 17, the local system can also be understood as the local operating system.

[0408] For ease of description, in the solutions of Figures 10 to 17 , the IDE front end is represented as a front end UI. Users can interact with the front end UI.

[0409] Figure 10 shows a schematic diagram of the solution of an embodiment of the present application applied to a local IDE development scenario. In the local IDE development scenario, the IDE front-end and the IDE back-end (such as the first IDE back-end in Figure 10) run on the same local operating system. The local IDE development scenario can also be replaced with a desktop IDE development scenario.

[0410] In development scenarios involving a local IDE, the front-end UI runs in the local IDE's client program, which is deployed on the local system. The local IDE's client program can also be replaced with a desktop IDE's client program.

[0411] Specifically, in the development scenario shown in Figure 10, the first IDE backend is also deployed in the local system. The first environment where the first IDE backend is located is the local system where the IDE frontend is located. That is, the IDE frontend and IDE backend run on the same local operating system.

[0412] In this scenario, the communication between the IDE front end and the first IDE back end can be implemented using inter-process communication. For example, as shown in FIG10 , the IDE front end and the first IDE back end can interact via inter-process communication (IPC).

[0413] Figure 11 shows a schematic diagram of the solution of an embodiment of the present application applied to a WebIDE development scenario. In the development scenario shown in Figure 11, a user can access the back-end server through a local browser to implement software development. An IDE back-end (the first IDE back-end as shown in Figure 11) is deployed on the back-end server. Alternatively, it can be understood that the back-end server is used to provide IDE back-end services and can also be referred to as an IDE back-end server. The IDE back-end can also be referred to as the IDE back-end of WebIDE.

[0414] In development scenarios involving WebIDE, the IDE front-end runs in a browser client program, as shown in Figure 11. The browser client program is deployed on the local system. The local browser is the browser client program deployed on the local system.

[0415] The environment where the first IDE backend resides can be a local backend server or a remote backend server. That is, the first IDE backend can be deployed on a local backend server or a remote backend server. Accordingly, users can access the IDE backend through a local browser to implement software development locally or remotely.

[0416] For ease of description, in the embodiments of the present application, both the local back-end server and the remote back-end server may be considered as remote environments.

[0417] As shown in Figure 11, the system to which the first environment belongs can be a homogeneous system or a heterogeneous system. That is, the first IDE backend can be deployed in either a homogeneous system or a heterogeneous system. In other words, users can access the IDE backend through a local browser to develop software in either homogeneous or heterogeneous system. Software development in either homogeneous or heterogeneous systems can also be replaced by developing applications in either homogeneous or heterogeneous system.

[0418] The first IDE backend can be deployed on various types of computing resources. For example, the first IDE backend can be deployed on a container or a virtual machine. For example, the computing resources of the remote environment can include any one or more of the following: a local container, a local virtual machine, a remote container, or a remote virtual machine. The first IDE backend can be deployed on any of the above.

[0419] In the development scenario shown in Figure 11, the communication between the IDE front end and the first IDE back end can be implemented using the communication method between the browser and the back end server. For example, as shown in Figure 11, the IDE front end and the first IDE back end can interact via HTTP.

[0420] Figure 12 shows a schematic diagram of the solution of an embodiment of the present application applied to another WebIDE development scenario. The main difference between Figures 11 and 12 is that the first IDE backend in Figure 12 runs in the browser client program. In other words, the host process of the first IDE backend can be the browser process, and the IDE frontend and the first IDE backend can run in different browser processes.

[0421] In the development scenario shown in Figure 12, the communication between the IDE front end and the first IDE back end can be implemented using an inter-process communication method. For example, as shown in Figure 12, the IDE front end and the first IDE back end can interact via IPC.

[0422] Figure 13 shows a schematic diagram of the solution of an embodiment of the present application applied to a local IDE in a remote development scenario. A user can access a backend server through a local IDE client program to implement software development. The backend server is deployed with an IDE backend (such as the first IDE backend in Figure 13).

[0423] In development scenarios involving a local IDE, the front-end UI runs in the local IDE's client program, which is deployed on the local system.

[0424] The first environment can be a local backend server or a remote backend server. That is, the first IDE backend can be deployed on a local backend server or a remote backend server. Accordingly, users can access the IDE backend through the local IDE client program to implement software development locally or remotely.

[0425] As shown in Figure 13 , the system to which the first environment belongs can be a homogeneous system and / or a heterogeneous system. That is, the first IDE backend can be deployed in either a homogeneous system or a heterogeneous system. In other words, users can access the IDE backend through a local IDE client program to implement software development in either homogeneous or heterogeneous system.

[0426] The first IDE backend can be deployed on various types of computing resources. For example, the first IDE backend can be deployed on a container or a virtual machine. For example, the computing resources of the remote environment can include any one or more of the following: a local container, a local virtual machine, a remote container, or a remote virtual machine. The first IDE backend can be deployed on any of the above.

[0427] In the development scenario shown in Figure 13 , communication between the IDE frontend and the first IDE backend can be implemented using the same client-server communication model. For example, as shown in Figure 13 , the IDE frontend and the first IDE backend can interact via an SSH tunnel, and the IDE frontend and the corresponding language service can communicate based on JSON RPC. For a detailed description, please refer to method 600 shown in Figure 9 .

[0428] Figure 14 shows a schematic diagram of the solution of an embodiment of the present application applied to a remote development scenario of WebIDE. In a development scenario involving WebIDE, the front-end UI runs in a browser client program, and the browser client program is deployed in a local system.

[0429] In the development scenario shown in Figure 14, a user can access the first IDE backend in remote environment #1 (an example of the first environment) through a local browser, and interact with the second IDE backend in remote environment #2 (an example of the second environment) through the first IDE backend in remote environment #1 to perform software development in remote environment #2. The first IDE backend in remote environment #1 is the IDE backend of WebIDE. Remote environment #1 and remote environment #2 are different remote environments. That is, a user can develop applications from the IDE frontend in a local browser in a remote environment other than the remote environment where the WebIDE IDE backend resides.

[0430] As shown in Figure 14, the IDE backend can be deployed in different remote environments.

[0431] The system to which the first environment belongs can be homogeneous and / or heterogeneous. That is, the first IDE backend can be deployed in either homogeneous or heterogeneous systems. The system to which the second environment belongs can be homogeneous and / or heterogeneous systems. That is, the second IDE backend can be deployed in either homogeneous or heterogeneous systems. In other words, users can develop software in either homogeneous or heterogeneous systems in remote environment #2 from the IDE frontend in their local browser.

[0432] The IDE backend can be deployed on various types of computing resources. For detailed descriptions, please refer to the previous article and will not be repeated here.

[0433] The development scenario shown in FIG14 is exemplarily described below.

[0434] For example, a user can log in to a cloud account through a local browser, and the IDE front end running in the local browser connects to the computing service on the cloud server through the cloud account to create a service instance. The type of hardware architecture pre-configured by the user may be type #1. In this case, a service instance is created on the hardware of type #1, and the IDE back end (an example of the first IDE back end) on the service instance is started, and the software development in remote environment #1 (an example of the first environment) is carried out. The IDE back end is the IDE back end on remote environment #1. During the development process, the user may need to carry out software development on hardware of other hardware architecture types (such as type #2). In this case, using the solution of the embodiment of the present application, the IDE back end on remote environment #1 can be connected to remote environment #2 (an example of the second environment), and the hardware of remote environment #2 includes the hardware of type #2. A service instance is created on the hardware of type #2, and the IDE back end (an example of the second IDE back end) on the service instance is started, thereby realizing the software development in remote environment #2.

[0435] In the development scenario shown in Figure 14, the communication between the IDE front-end and the IDE back-end of WebIDE can adopt the communication method between the browser and the server, and the IDE back-end of WebIDE and the IDE back-end in other remote environments can adopt the communication method between servers.

[0436] For example, as shown in Figure 14, during the software development process, the IDE front-end and the IDE back-end of WebIDE can communicate through HTTP, and the IDE back-ends of WebIDE and IDE back-ends in other remote environments can interact through SSH tunnels, such as interaction based on JSON RPC.

[0437] As described in method 600 above, the user's code activities, such as editing, debugging, testing, compiling, building, etc., can be sent by the IDE front end to the corresponding language service for processing in the form of a request. The language service can return the processing result to the IDE front end, and the IDE front end will display the processing result to the user. In the scheme shown in Figure 14, the language service is provided by the IDE back end in remote environment #2 (the second IDE back end in Figure 14). Specifically, the IDE front end can send the user's code activity request to the IDE back end of WebIDE (the first IDE back end in Figure 14) through an HTTP request, and the IDE back end of WebIDE forwards the request to the IDE back end of remote environment #2 through the SSH tunnel established between the IDE back end of WebIDE and remote environment #2, that is, it lands in the IDE back end component of the remote environment, so that the user can develop applications in the isomorphic or heterogeneous system of remote environment #2 in the IDE front end of the local browser.

[0438] Figures 15 to 17 show schematic diagrams of three application projections according to embodiments of the present application. GUI programs A to D in the local system in Figures 15 to 17 are the projected GUI programs A to D.

[0439] Figure 15 shows a schematic diagram of the solution of an embodiment of the present application applied to a local IDE development scenario. The main difference between the solution of Figure 15 and the solution of Figure 10 is that the solution shown in Figure 15 involves application projection. To avoid repetition, the description of the solution shown in Figure 15 will focus on the differences between it and Figure 10, and other descriptions can refer to the solution of Figure 10.

[0440] The first IDE backend may establish a connection with one or more remote environments, so that GUI programs in the one or more remote environments may be projected into the local system.

[0441] Exemplarily, the first IDE backend may establish SSH tunnels with the one or more remote environments respectively, so that the GUI programs in the one or more remote environments can be projected into the local system.

[0442] The number of GUI programs in the one or more remote environments can be one or more. For example, as shown in FIG15 , the first IDE backend establishes SSH tunnels with two remote environments respectively, so that four GUI programs (i.e., GUI program A, GUI program B, GUI program C, and GUI program D) in the two remote environments can be projected into the local system, and the four GUI programs can be displayed simultaneously in the front-end UI.

[0443] It should be understood that the number of remote environments where the GUI programs in FIG15 are located and the number of GUI programs in each remote environment are merely examples and do not constitute a limitation on the solutions of the embodiments of the present application.

[0444] Figure 16 shows a schematic diagram of the solution of an embodiment of the present application applied to a WebIDE development scenario. The main difference between the solution in Figure 16 and the solution in Figure 11 is that the solution shown in Figure 16 involves application projection. To avoid repetition, the description of the solution shown in Figure 16 will focus on the differences between it and Figure 11. For other descriptions, please refer to the solution in Figure 11.

[0445] Figure 16 shows a first IDE backend deployed in a first environment. In the solution shown in Figure 16, the first environment and the third environment are different. The first IDE backend can establish a connection with one or more third environments so that GUI programs in the one or more third environments can be projected onto the local system.

[0446] Exemplarily, the first IDE backend may establish an SSH tunnel with the one or more third environments, so that the GUI programs in the one or more third environments may be projected into the local system.

[0447] As previously described, users can access the first IDE backend deployed in the first environment through a local browser. For example, the local browser can establish an SSH tunnel with the first environment, i.e., an SSH tunnel browser (SSH-in-browser). The first environment establishes an SSH tunnel with the third environment, so that the GUI program in the third environment can be projected into the local system.

[0448] The number of GUI programs in the one or more third environments can be one or more. For example, as shown in Figure 16, a user can access the first IDE backend deployed in two first environments through a local browser. The local browser establishes SSH tunnels with the two first environments, and the two first environments establish SSH tunnels with the two third environments. Through the display server protocol, the four GUI programs in the two third environments can be projected into the local system and displayed simultaneously in the front-end UI.

[0449] It should be understood that the number of remote environments where the GUI programs in FIG16 are located and the number of GUI programs in each remote environment are merely examples and do not constitute a limitation on the solutions of the embodiments of the present application.

[0450] Figure 17 shows a schematic diagram of the solution of an embodiment of the present application applied to a local IDE in a remote development scenario. The main difference between the solution of Figure 17 and the solution of Figure 13 is that the solution shown in Figure 17 involves application projection. To avoid repetition, the description of the solution shown in Figure 17 will focus on the differences between it and Figure 13, and other descriptions can refer to the solution of Figure 13.

[0451] The first IDE backend is deployed in the first environment. In the solution shown in Figure 17, the first environment and the third environment are different. Figure 17 shows that the first IDE backend can establish a connection with one or more third environments so that the GUI programs in the one or more third environments can be projected into the local system.

[0452] Exemplarily, the first IDE backend may establish an SSH tunnel with the one or more third environments, so that the GUI programs in the one or more third environments may be projected into the local system.

[0453] The user can access the backend server in the first environment through the client program of the local IDE to implement software development. For example, the client program of the local IDE can establish an SSH tunnel with the first environment, and the first environment establishes an SSH tunnel with the third environment, so that the GUI program in the third environment can be projected into the local system.

[0454] The number of GUI programs in the one or more third environments can be one or more. For example, as shown in Figure 17, a user can access the first IDE backend deployed in two first environments through the local IDE client program. The local IDE client program establishes SSH tunnels with the two first environments, and the two first environments establish SSH tunnels with the two third environments. Through the display server protocol, the four GUI programs in the two third environments can be projected into the local system, and the four GUI programs can be displayed simultaneously in the front-end UI.

[0455] It should be understood that the number of remote environments where the GUI programs in FIG17 are located and the number of GUI programs in each remote environment are merely examples and do not constitute a limitation on the solutions of the embodiments of the present application.

[0456] Figure 18 shows a flow chart of a method for software development according to an embodiment of the present application. The method shown in Figure 18 can be regarded as a specific implementation of method 600 shown in Figure 9. The specific description can refer to method 600. To avoid repetition, some descriptions are appropriately omitted when describing method 700. The IDE in method 700 adopts the IDE architecture shown in Figure 2. That is, the IDE backend service in method 700 can be the first IDE backend 220 in Figure 2 and / or the first IDE backend in Figure 6, and the IDE frontend in method 700 can be the IDE frontend 210 in Figure 2. The service instance in method 700 is the instance in method 600.

[0457] The method 700 shown in FIG. 18 may be applied to a development scenario in which a local IDE is remotely developed, for example, the development scenario shown in FIG. 13 .

[0458] Exemplarily, the method 700 shown in FIG18 can be applied to a scenario where a local device is combined with a cloud server, or in other words, the method 700 can be applied to a scenario where a local device is combined with a cloud computing service, that is, the first IDE backend 220 can be deployed on a cloud computing service.

[0459] As shown in FIG. 18 , method 700 may include the following steps.

[0460] 710, start the IDE.

[0461] The user starts the client program of the local IDE, that is, starts the IDE front end, or starts the IDE.

[0462] The IDE front-end can automatically connect to the cloud computing service through the configured account and create a service instance.

[0463] For example, after a user launches the IDE, a login screen may be displayed, prompting the user to log in with their account. After logging in, the IDE front-end can connect to the cloud computing service using the user's account and create service instances for various programming languages. For example, as shown in Figure 18, a Java service instance and a Python service instance are created for the user.

[0464] It should be understood that the implementation of the service instance by the container in the solution shown in Figure 18 is only an example and does not limit the solution of the embodiment of the present application. For example, in other implementations, the service instance can be implemented by a virtual machine.

[0465] It should be understood that the number of service instances and the corresponding programming languages ​​in the solution shown in Figure 18 are only examples and do not limit the solution of the embodiment of the present application. In other implementations, other numbers of service instances and / or service instances of other programming languages ​​can also be created.

[0466] The type of the hardware architecture of the service instance can be pre-configured by the user. For example, if the user pre-configures the type of the hardware architecture of the service instance as hardware type #1, a service instance is created for the user based on the hardware architecture of hardware type #1.

[0467] 720, create project.

[0468] For example, a user may create a project using a project template provided by an IDE.

[0469] Taking a multi-language project as an example, users can create a multi-language project using the project template provided by the IDE. For example, the programming languages ​​involved in this multi-language project are Java and Python.

[0470] 730, obtain activation operation (an example of the first operation).

[0471] When the IDE front end receives the user's activation operation, it can activate the corresponding language service.

[0472] When the user performs certain operations, the IDE can automatically activate the corresponding language service based on the current context, that is, realize context-aware language service activation. These operations are activation operations.

[0473] Exemplarily, the activation operation can be opening a code file (i.e., a language file) in a project. For example, when a user opens a Java file for the first time, the IDE can activate the Java language service based on the current context. For another example, when a user opens a Python file for the first time, the IDE can activate the Python language service based on the current context.

[0474] The following uses the Java language service as an example to illustrate the activation process. For example, after a user creates a multi-language project that includes Java and Python, opening a Java file in the project triggers the Java language service activation process. The activation process can include the following steps.

[0475] 731, The IDE front-end establishes an SSH connection with the Java service instance.

[0476] 732, start the IDE backend service in the Java service instance, and send the remote port monitored by the IDE backend service to the IDE front end.

[0477] Specifically, the IDE front-end checks whether the container (i.e., Java container) in the service instance has the IDE back-end service deployed. If so, it starts the IDE back-end service. If not, it deploys the IDE back-end service in the container and starts the IDE back-end service.

[0478] Send the remote port monitored by the IDE backend service to the IDE frontend.

[0479] 733, the IDE front-end establishes an SSH tunnel between the local port and the remote port (local port: remote port), upgrading the HTTP connection to a WebSocket connection. In this way, all subsequent service requests can interact through this connection.

[0480] If the user does not need the IDE backend service, you can stop the IDE backend service. The trigger method for stopping the IDE backend service can be set as needed.

[0481] For example, if a project is closed, the IDE backend services associated with that project can be stopped. For example, if a user creates a multi-language project that includes Java and Python and then activates it, the Java language service and the Python language service are activated. This means that the IDE backend services for providing the Java and Python language services are started. If the user closes the language project, the IDE backend services for providing the Java and Python language services can be stopped.

[0482] For example, if the IDE front-end is closed, all IDE back-end services that interact with the IDE front-end may be stopped.

[0483] Furthermore, you can also close the SSH tunnel.

[0484] 740, obtain code operation.

[0485] When the IDE front-end obtains the user's code operation, it can send the user's code operation to the language service for processing in the form of a service request. After processing, the language service returns the processing result to the IDE front-end, which is displayed to the user.

[0486] 750, close the IDE.

[0487] If the user closes the IDE, the IDE front-end can notify the Compute service to destroy the service instance.

[0488] For example, when a user closes an IDE, the IDE front-end can notify the computing service to destroy all service instances created when the IDE front-end was started.

[0489] Taking the solution shown in FIG18 as an example, when the user closes the IDE, the two service instances in FIG18 can be destroyed.

[0490] The apparatus of the embodiment of the present application is described below with reference to Figures 19 to 22. It should be understood that the apparatus described below can execute the method of the aforementioned embodiment of the present application. To avoid unnecessary repetition, repeated descriptions are appropriately omitted when introducing the apparatus of the embodiment of the present application.

[0491] Figure 19 is a schematic block diagram of a system for software development according to an embodiment of the present application. The system 2000 shown in Figure 19 can be used to execute the method shown in Figure 9 and / or Figure 18.

[0492] As shown in Figure 19, system 2000 may include an IDE front end 2010 and a first IDE back end 2020. The IDE front end may be the IDE front end 210 in Figure 2. The first IDE back end 2020 may be the first IDE back end 220 in Figure 2.

[0493] The first IDE backend 2020 supports running in multiple types of environments, where the multiple types of environments include at least one of the following: multiple types of operating systems or multiple types of hardware architectures.

[0494] The IDE front-end 2010 is used to obtain the user's configuration information, where the configuration information includes at least one of the following: the type of hardware architecture or the type of operating system; and deploying the first IDE back-end 2020 in the first environment according to the configuration information, so that software development on the first IDE back-end 2020 in the first environment can be implemented through the IDE front-end 2010, where the first environment is an environment determined according to the configuration information among the multiple types of environments supported by the first IDE back-end.

[0495] Optionally, the IDE front end 2010 runs on a client program of the IDE or a client program of a browser.

[0496] Optionally, the IDE front end 2010 includes a user interface UI component and an adaptation layer, the UI component is used to provide a user interface, and the adaptation layer is used to provide a unified interface for the UI component so that the UI component can run in one or more client programs.

[0497] Optionally, the first IDE backend 2020 includes an IDE kernel, which is used to provide language features of multiple programming languages.

[0498] Optionally, the DE kernel includes: an index system for storing index information of the source code, a language parsing adaptation layer for calling a language parser corresponding to the programming language of the source code to parse the source code, and a language feature layer for providing language features of multiple programming languages, including the programming language of the source code.

[0499] Optionally, the multiple types of environments include a local system where the IDE front-end 2010 is located and / or other environments outside the local system.

[0500] Optionally, the first environment includes one or more instances, and the IDE front-end 2010 is specifically used to: obtain one or more instances based on the configuration information, and the first IDE back-end 2020 is deployed in one or more instances; or, obtain one or more instances based on the configuration information; when the first IDE back-end 2020 is not deployed in some or all of the one or more instances, deploy the first IDE back-end 2020 in the instance where the first IDE back-end 2020 is not deployed.

[0501] Optionally, the IDE front-end 2010 is further configured to start a first IDE back-end 2020 in a first instance of the one or more instances, so that the first IDE back-end 2020 in the first instance provides language features of a first programming language supported by the first instance.

[0502] Optionally, the IDE front-end 2010 is further configured to establish a persistent connection with the first IDE back-end 2020 in the first instance.

[0503] Optionally, the IDE front-end 2010 is specifically configured to: start a first IDE back-end 2020 in a first instance according to a first operation, where the first operation indicates a first programming language.

[0504] Optionally, the first operation includes an operation of opening a first code file, and the first programming language is a programming language of the first code file.

[0505] Optionally, the configuration information is indicated by a login request carrying verification information.

[0506] Optionally, the IDE front end 2010 is further configured to: send the first request to the first IDE back end 2020 in the first environment; and the first IDE back end 2020 in the first environment is configured to: generate a first response to the first request; and return the first response to the IDE front end 2010 .

[0507] Optionally, the system also includes a second IDE backend running in the second environment, and the IDE front end 2010 is also used to: send the second request to the first IDE back end 2020 in the first environment; the first IDE back end 2020 in the first environment is used to forward the second request to the second IDE back end in the second environment; the second IDE back end in the second environment is used to: generate a second response to the second request; send the second response to the first IDE back end 2020 in the first environment; and the first IDE back end 2020 in the first environment is also used to: return the second response to the IDE front end 2010.

[0508] Optionally, the first IDE backend 2020 in the first environment is further configured to project the graphical user interface program running in the remote environment to the local system where the IDE frontend 2010 is located through a display server protocol.

[0509] For detailed description, please refer to method 600 and method 700 in the previous text, which will not be repeated here.

[0510] Each module in system 2000 can be implemented via software or hardware. For example, the implementation of first IDE backend 2020 will be described below using the example of first IDE backend 2020. Similarly, the implementation of other modules can refer to the implementation of first IDE backend 2020.

[0511] As an example of a software functional unit, the first IDE backend 2020 may include code running on a computing instance. The computing instance may include at least one of a physical host (computing device), a virtual machine, and a container. Furthermore, the computing instance may be one or more. For example, the first IDE backend 2020 may include code running on multiple hosts / virtual machines / containers. It should be noted that the multiple hosts / virtual machines / containers used to run the code may be distributed in the same region or in different regions. Furthermore, the multiple hosts / virtual machines / containers used to run the code may be distributed in the same availability zone (AZ) or in different AZs, each AZ including one data center or multiple geographically close data centers. Typically, a region may include multiple AZs.

[0512] Similarly, multiple hosts / virtual machines / containers running the code can be distributed within the same virtual private cloud (VPC) or across multiple VPCs. Typically, a VPC is set up within a region. Cross-region communication between two VPCs within the same region, or between VPCs in different regions, requires a communication gateway within each VPC to interconnect the VPCs.

[0513] As an example of a hardware functional unit, the first IDE backend 2020 may include at least one computing device, such as a server. Alternatively, the first IDE backend 2020 may be implemented using an application-specific integrated circuit (ASIC) or a programmable logic device (PLD). The PLD may be a complex programmable logical device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof.

[0514] The multiple computing devices included in the first IDE backend 2020 can be distributed in the same region or in different regions. The multiple computing devices included in the first IDE backend 2020 can be distributed in the same AZ or in different AZs. Similarly, the multiple computing devices included in the first IDE backend 2020 can be distributed in the same VPC or in multiple VPCs. The multiple computing devices can be any combination of computing devices such as servers, ASICs, PLDs, CPLDs, FPGAs, and GALs.

[0515] It should be noted that, in other embodiments, the first IDE backend 2020 can be used to execute any step in the method for software development, and other modules can be used to implement any step in the method for software development. The steps that each module is responsible for implementing can be specified as needed, and all functions of the system 2000 are realized by implementing different steps in the method for software development through each module.

[0516] This application also provides a computing device 1000. As shown in FIG20 , computing device 1000 includes a bus 1002, a processor 1004, a memory 1006, and a communication interface 1008. Processor 1004, memory 1006, and communication interface 1008 communicate with each other via bus 1002. Computing device 1000 can be a server or a terminal device. It should be understood that this application does not limit the number of processors and memories in computing device 1000.

[0517] Bus 1002 may be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, among others. Buses may be classified as address buses, data buses, control buses, and the like. For ease of illustration, FIG20 illustrates a single bus line, but this does not imply a single bus or type of bus. Bus 1002 may include a path for transmitting information between various components of computing device 1000 (e.g., memory 1006, processor 1004, and communication interface 1008).

[0518] The processor 1004 may include any one or more processors such as a central processing unit (CPU), a graphics processing unit (GPU), a microprocessor (MP), or a digital signal processor (DSP).

[0519] The memory 1006 may include volatile memory, such as random access memory (RAM). The processor 1004 may also include non-volatile memory, such as read-only memory (ROM), flash memory, hard disk drive (HDD), or solid state drive (SSD).

[0520] The memory 1006 stores executable program codes, and the processor 1004 executes the executable program codes to respectively implement the functions of the aforementioned modules, thereby implementing the method for software development. In other words, the memory 1006 stores instructions for executing the method for software development.

[0521] The communication interface 1008 uses a transceiver module such as, but not limited to, a network interface card or a transceiver to implement communication between the computing device 1000 and other devices or a communication network.

[0522] Embodiments of the present application also provide a computing device cluster. The computing device cluster includes at least one computing device. The computing device can be a server, such as a central server, an edge server, or a local server in a local data center. In some embodiments, the computing device can also be a terminal device such as a desktop computer, a laptop computer, or a smartphone.

[0523] As shown in Figure 21, the computing device cluster includes at least one computing device 1000. The memory 1006 in one or more computing devices 1000 in the computing device cluster may store the same instructions for executing the method for software development.

[0524] In some possible implementations, the memory 1006 of one or more computing devices 1000 in the computing device cluster may also store partial instructions for executing the method for software development. In other words, the combination of one or more computing devices 1000 can jointly execute the instructions for the method for software development.

[0525] It should be noted that the memory 1006 in different computing devices 1000 in the computing device cluster can store different instructions, each for executing a portion of the functions of the system for software development. In other words, the instructions stored in the memory 1006 in different computing devices 1000 can implement the functions of one or more modules in the system 2000.

[0526] In some possible implementations, one or more computing devices in a computing device cluster may be connected via a network, which may be a wide area network or a local area network.

[0527] Figure 22 illustrates a possible implementation. As shown in Figure 22 , two computing devices 1000A and 1000B are connected via a network. Specifically, the connection to the network is achieved via a communication interface within each computing device. In this possible implementation, the memory 1006 within computing device 1000A stores instructions for executing the functions of an IDE front-end 2010. Simultaneously, the memory 1006 within computing device 1000B stores instructions for executing the functions of a first IDE back-end 2020.

[0528] It should be understood that the functions of the computing device 1000A shown in FIG22 may also be completed by multiple computing devices 1000. Similarly, the functions of the computing device 1000B may also be completed by multiple computing devices 1000.

[0529] The present application also provides a computer program product comprising instructions. The computer program product may be software or a program product comprising instructions that can be run on a computing device or stored in any available medium. When the computer program product is run on at least one computing device, the at least one computing device executes a method for software development.

[0530] The present application also provides a computer-readable storage medium. The computer-readable storage medium can be any available medium that can be stored by a computing device or a data storage device such as a data center that contains one or more available media. The available medium can be a magnetic medium (e.g., a floppy disk, a hard disk, a magnetic tape), an optical medium (e.g., a DVD), or a semiconductor medium (e.g., a solid-state drive). The computer-readable storage medium includes instructions that instruct the computing device to execute a method for software development.

[0531] Those skilled in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0532] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0533] In the several embodiments provided in this application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are merely schematic. For example, the division of the units is merely a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0534] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of these units may be selected to achieve the purpose of this embodiment according to actual needs.

[0535] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0536] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the processing method described in each embodiment of the present application. The aforementioned storage medium includes: various media that can store program codes, such as a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0537] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

Claims

1. A method for software development, characterized in that The method is applied to an integrated development environment (IDE), wherein the IDE includes an IDE front end and a first IDE back end, wherein the first IDE back end supports running in multiple types of environments, wherein the multiple types of environments include at least one of the following: multiple types of operating systems or multiple types of hardware architectures. The IDE front end obtains user configuration information, wherein the configuration information includes at least one of the following: a type of hardware architecture or a type of operating system; The IDE front-end deploys the first IDE back-end in a first environment according to the configuration information, so that software development on the first IDE back-end in the first environment is implemented through the IDE front-end. The first environment is an environment determined according to the user's configuration information among multiple types of environments supported by the first IDE back-end.

2. The method according to claim 1, characterized in that The IDE front end runs on the client program of the IDE or the client program of the browser.

3. The method according to claim 2, characterized in that The IDE front end includes a user interface UI component and an adaptation layer. The UI component is used to provide the user interface, and the adaptation layer is used to provide a unified interface for the UI component so that the UI component can run in one or more client programs.

4. The method according to any one of claims 1 to 3, characterized in that The first IDE backend includes an IDE kernel, and the IDE kernel is used to provide language features of multiple programming languages.

5. The method according to claim 4, characterized in that The IDE kernel includes: Indexing system, used to store index information of source code, A language parsing adaptation layer, configured to call a language parser corresponding to the programming language of the source code to parse the source code, The language feature layer is configured to provide language features of the plurality of programming languages, wherein the plurality of programming languages ​​includes the programming language of the source code.

6. The method according to any one of claims 1 to 5, characterized in that The multiple types of environments include a local system where the IDE front end is located and / or other environments outside the local system.

7. The method according to any one of claims 1 to 6, characterized in that The first environment includes one or more instances, and the IDE front-end deploys the first IDE back-end on the first environment according to the configuration information, including: The IDE front end obtains the one or more instances according to the configuration information, wherein the first IDE back end is deployed in the one or more instances; or The IDE front end obtains the one or more instances according to the configuration information; In a case where the first IDE backend is not deployed in some or all of the one or more instances, the IDE front-end deploys the first IDE backend in the instances where the first IDE backend is not deployed.

8. The method according to claim 7, characterized in that The method further comprises: The IDE front-end starts the first IDE back-end in a first instance among the one or more instances, so that the first IDE back-end in the first instance provides language features of a first programming language supported by the first instance.

9. The method according to claim 8, characterized in that The method further comprises: The IDE front end establishes a persistent connection with the first IDE back end in the first instance.

10. The method according to claim 8 or 9, characterized in that The IDE front end starts the first IDE back end in a first instance among the one or more instances, including: The IDE front end starts the first IDE back end in the first instance according to a first operation, where the first operation indicates the first programming language.

11. The method according to claim 10, characterized in that The first operation includes an opening operation of a first code file, and the first programming language is the programming language of the first code file.

12. The method according to any one of claims 1 to 11, characterized in that The configuration information is indicated by a login request carrying verification information.

13. The method according to any one of claims 1 to 12, characterized in that The method further comprises: The IDE front end sends the first request to the first IDE back end in the first environment; The first IDE backend in the first environment generates a first response to the first request; The first IDE backend in the first environment returns the first response to the IDE frontend.

14. The method according to any one of claims 1 to 12, characterized in that The IDE further includes a second IDE backend running in a second environment, and the method further includes: The IDE front end sends the second request to the first IDE back end in the first environment; The first IDE backend in the first environment forwards the second request to the second IDE backend in the second environment; The second IDE backend in the second environment generates a second response to the second request; The second IDE backend in the second environment sends the second response to the first IDE backend in the first environment; The first IDE backend in the first environment returns the second response to the IDE frontend.

15. The method according to any one of claims 1 to 14, characterized in that The method further comprises: The first IDE backend in the first environment projects the graphical user interface program running in the remote environment to the local system where the IDE frontend is located through a display server protocol.

16. A system for software development, characterized in that include: An integrated development environment (IDE) front-end and a first IDE back-end, wherein the first IDE back-end supports running in multiple types of environments, wherein the multiple types of environments include at least one of the following: multiple types of operating systems or multiple types of hardware architectures, The IDE front end is used to: Acquiring user configuration information, where the configuration information includes at least one of the following: a type of hardware architecture or a type of operating system; The first IDE backend is deployed in a first environment according to the configuration information, so that software development on the first IDE backend in the first environment is implemented through the IDE front-end. The first environment is an environment determined according to the user's configuration information among multiple types of environments supported by the first IDE backend.

17. The system according to claim 16, wherein: The IDE front end runs on the IDE client program or the browser client program.

18. The system according to claim 17, wherein: The IDE front end includes a user interface UI component and an adaptation layer. The UI component is used to provide the user interface, and the adaptation layer is used to provide a unified interface for the UI component so that the UI component can run in one or more client programs.

19. The system according to any one of claims 16 to 18, characterized in that The first IDE backend includes an IDE kernel, and the IDE kernel is used to provide language features of multiple programming languages.

20. The system according to claim 19, wherein: The IDE kernel includes: Indexing system, used to store index information of source code, A language parsing adaptation layer, configured to call a language parser corresponding to the programming language of the source code to parse the source code, The language feature layer is configured to provide language features of the plurality of programming languages, wherein the plurality of programming languages ​​includes the programming language of the source code.

21. The system according to any one of claims 16 to 20, characterized in that The multiple types of environments include a local system where the IDE front end is located and / or other environments outside the local system.

22. The system according to any one of claims 16 to 21, characterized in that The first environment includes one or more instances, and the IDE front end is specifically used to: Acquire the one or more instances according to the configuration information, wherein the first IDE backend is deployed in the one or more instances; or Acquire the one or more instances according to the configuration information; If the first IDE backend is not deployed in some or all of the one or more instances, the first IDE backend is deployed in the instances where the first IDE backend is not deployed.

23. The system according to claim 22, wherein: The IDE front end is also used to: The first IDE backend in a first instance of the one or more instances is started, so that the first IDE backend in the first instance provides language features of a first programming language supported by the first instance.

24. The system according to claim 23, wherein: The IDE front end is also used to: Establish a persistent connection with the first IDE backend in the first instance.

25. The system according to claim 23 or 24, characterized in that The IDE front end is specifically used for: The first IDE backend in the first instance is started according to a first operation, where the first operation indicates the first programming language.

26. The system according to claim 25, characterized in that The first operation includes an opening operation of a first code file, and the first programming language is the programming language of the first code file.

27. The system according to any one of claims 16 to 26, characterized in that The configuration information is indicated by a login request carrying verification information.

28. The system according to any one of claims 16 to 27, characterized in that The IDE front end is also used to: The first request is sent to a first IDE backend in the first environment; and the first IDE backend in the first environment is configured to: generating a first response to the first request; The first response is returned to the IDE front end.

29. The system according to any one of claims 16 to 27, characterized in that The system further includes a second IDE backend running in a second environment, and the IDE frontend is further configured to: Sending a second request to the first IDE backend in the first environment; The first IDE backend in the first environment is used to forward the second request to the second IDE backend in the second environment; The second IDE backend in the second environment is used for: generating a second response to the second request; sending the second response to the first IDE backend in the first environment; and the first IDE backend in the first environment is further configured to: The second response is returned to the IDE front end.

30. The system according to any one of claims 16 to 29, characterized in that The first IDE backend in the first environment is further configured to project the graphical user interface program running in the remote environment to the local system where the IDE frontend is located through a display server protocol.

31. A computing device cluster, characterized in that: comprising at least one computing device, each computing device including a processor and a memory; The processor of the at least one computing device is configured to execute instructions stored in a memory of the at least one computing device, so that the computing device cluster executes the method according to any one of claims 1 to 15.

32. A computer-readable storage medium, characterized in that The method comprises computer program instructions, which, when executed by a computing device cluster, perform the method according to any one of claims 1 to 15.

33. A computer program product comprising instructions, characterized in that When the instructions are executed by a computing device cluster, the computing device cluster is caused to perform the method according to any one of claims 1 to 15.

Images