Transforming application into micro-service architecture

Abstract

A system for transforming applications for a distributed computing environment is provided. The system includes one or more memories, and at least one processor coupled to the one or more memories. The system analyzes the description of the user intent to extract information for the transformation application. The extracted information indicates functionality for the distributed computing environment. A plurality of software articles of an application are mapped to a function. The plurality of software articles form different groups of software articles. The remaining software articles of the application are assigned into different groups based on the remaining software articles corresponding to a group of mapped software articles. The different groups correspond to micro-services of the distributed computing environment. Microservices of the distributed computing environment are presented based on the different groups.

Description

Background Art 1. Technical Field

[0001] Embodiments of the present invention relate to cloud or other distributed computing, and more particularly, to transforming applications into a microservices architecture for cloud or other distributed computing environments based on user intent obtained from natural language processing.

[0002] 2. Related technical discussions

[0003] Customers are increasingly performing application modernization in order to simplify the management of resources (e.g., infrastructure, human resources, etc.), scale applications, reduce costs, and enrich the customer experience. This is even more attractive during the transition to a cloud computing environment (or microservices), as this transition inevitably forces customers to significantly change their applications to support the cloud.

[0004] However, current approaches to providing microservice recommendations for application modernization are primarily bottom-up driven. In other words, the boundaries of the functionality recommended for microservices are detected from the implementation structure of the application code, without any external reference (i.e., inferring recommendations from current code, tables, user interface screens, interfaces, data access objects (DAOs), service entry points (SEPs), etc.). In some cases, greenfield development (i.e., writing or generating code from scratch) is preferred to avoid impact from existing implementation structures. In other cases, reuse of related code is preferred for modernization or standardization.

[0005] Although Domain Driven Design (DDD) concepts are business driven, these concepts cannot be easily overlaid on monolithic code (e.g., a single-tier or non-distributed software application that combines code for user interface and data access, and a single deployable application that is typically large) to perform modernization. This is because Domain Driven Design (DDD) concepts are primarily applicable to the composition of applications that are intended to be divided based on modules and the corresponding teams that can support those modules. Summary of the invention

[0006] According to one embodiment of the present invention, a system transforms an application for use in a distributed computing environment. The system includes one or more memories, and at least one processor coupled to the one or more memories. The system analyzes a description of user intent to extract information for transforming the application. The extracted information indicates functions for a distributed computing environment. Multiple software products of the application are mapped to functions. The multiple software products form different groups of software products. Based on the correspondence of the remaining software products to the mapped software products of the groups, the remaining software products of the application are allocated to different groups. Different groups correspond to microservices of a distributed computing environment. Microservices of a distributed computing environment are presented based on different groups. Embodiments of the present invention also include methods and computer program products for transforming applications for use in a distributed computing environment in substantially the same manner as described above. BRIEF DESCRIPTION OF THE DRAWINGS

[0007] Generally, the same reference numerals are used to denote the same components in the various drawings.

[0008] Figure 1 is a schematic diagram of an example computing environment according to an embodiment of the present invention.

[0009] Figure 2 is a flowchart of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention.

[0010] Figure 3 is a block diagram of an intent analysis module according to an embodiment of the present invention.

[0011] Figure 4 is a process flow chart of a method for transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention.

[0012] Figure 5 is an illustration of an example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention.

[0013] Figure 6 is an illustration of another example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention.

[0014] Figure 7 is a diagram of yet another example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. DETAILED DESCRIPTION

[0015] Embodiments of the present invention enable users to specify intents (e.g., keywords, natural language text, project descriptions, reference models, etc.) for application modernization, which drives the extraction or recommendation of microservices for monolithic applications or code (e.g., single-layer or non-distributed software applications that combine code for user interface and data access, and generally large single deployable applications). However, any application can be transformed into a microservice or other distributed computing architecture. Embodiments of the present invention accept user intent in the form of natural language descriptions, keywords, project descriptions, or reference models, and map the user intent to software artifacts of monolithic applications. Software artifacts may include any items related to the software or code of the application (e.g., modules or programs of source and / or compiled code, documents, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). The mapped modules are preferably used as seeds for clustering application functions (or other code modules) into microservices (e.g., a collection of distributed services, each of which is developed as part of a set of services that provide an overall process).

[0016] Embodiments of the present invention enable users (e.g., subject matter experts (SMEs), etc.) to specify modernization target states for monolithic or other applications using keywords, natural language text, project descriptions, or reference models to indicate user intent. Relationships are automatically established between user intent and software artifacts of the monolithic application (e.g., modules or programs of source and / or compiled code, documents, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). Functions that cannot be mapped to user intent are discovered and may be discarded (or excluded) from modernization as dead code, or may be confirmed by the user and included for modernization. Software artifacts that align with user intent are prompted for each microservice, and microservices that adhere to the user intent are generated to transform the monolithic application into a microservices-based (or distributed) architecture.

[0017] Current approaches to providing microservice recommendations for application modernization are primarily bottom-up driven. In other words, the boundaries of the functionality recommended for microservices are detected from the implementation structure of the application code without any external reference (i.e., inferring recommendations from current code, tables, UI screens, interfaces, data access objects (DAOs), service entry points (SEPs), etc.).

[0018] However, these approaches have several disadvantages. For example, the lack of standardization can lead to management difficulties and difficulty in complying with new standards introduced in the domain. The lack of standardization may be caused by several factors. As an example, some endpoints exposed in a monolithic application (e.g., related to display or temporary scenarios) may not be necessary in the target service model, and the functional granularity in the monolithic endpoints may be misleading (e.g., an endpoint in a monolithic application can perform the functions of several endpoints in a user-defined model). In addition, the member fields of methods in a monolithic application may be misleading in terms of number and naming. In addition, since transactions in a monolithic application can all be completed in a smaller number of method functions, it may become difficult to determine ownership. In addition, since microservice recommendations need to make sense and provide a comfort level for end users to assign teams to produce or maintain the recommended microservices, end users should be involved from the beginning of the transformation or decomposition task.

[0019] Therefore, embodiments of the present invention consider user intent mapped to key modules of a monolithic or other application, and prompt other modules to detect the scope of refactoring or transformation in order to recommend microservices. Embodiments of the present invention combine keyword expansion, data structure comparison, annotation, program analysis features based on static code analysis (e.g., transactions, etc.) to compare the definition of a monolithic program. Embodiments of the present invention map user intent to software artifacts (e.g., modules or programs) of a monolithic application, abstract software artifacts of a monolithic application to detect common functionality, and prompt and confirm the scope of clustering (or recommended microservices).

[0020] Various aspects of the present disclosure are described by narrative text, flow charts, block diagrams of computer systems, and / or block diagrams of machine logic included in computer program product (CPP) embodiments. With respect to any flow chart, depending on the technology involved, the operations may be performed in an order different from the order shown in a given flow chart. For example, again depending on the technology involved, two operations shown in consecutive flow chart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that at least partially overlaps in time.

[0021] Computer program product embodiments ("CPP embodiments" or "CPP") are terms used in this disclosure to describe any collection of one or more storage media (also referred to as "media") collectively included in a collection of one or more storage devices that collectively include machine-readable code corresponding to instructions and / or data for performing the computer operations specified in a given CPP claim. A "storage device" is any tangible device that can hold and store instructions for use by a computer processor. Without limitation, a computer-readable storage medium may be an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination of the foregoing. Some known types of storage devices that include these media include: magnetic disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), static random access memories (SRAM), compact disk read-only memories (CD-ROM), digital versatile disks (DVD), memory sticks, floppy disks, mechanical encoding devices (such as punch cards or pits / land formed in a major surface of a disk), or any suitable combination of the foregoing. Computer-readable storage media, as the term is used in this disclosure, should not be construed as storing in the form of transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, light pulses transmitted through fiber optic cables, electrical signals transmitted through wires and / or other transmission media. As will be appreciated by those skilled in the art, data is typically moved at certain occasional points in time during normal operation of the storage device, such as during access, defragmentation, or garbage collection, but this does not make the storage device transient because the data is not transient while it is stored.

[0022] refer to Figure 1, computing environment 100 includes an example of an environment for executing at least some of the computer codes involved in performing the methods of the present invention, such as transformation code 200. In addition to block 200, computing environment 100 includes, for example, computer 101, wide area network (WAN) 102, end user device (EUD) 103, remote server 104, public cloud 105, and private cloud 106. In this embodiment, computer 101 includes a processor set 110 (including processing circuit 120 and cache 121), communication structure 111, volatile memory 112, permanent storage device 113 (including operating system 122 and block 200, as described above), peripheral device set 114 (including user interface (UI) device set 123, storage device 124, and Internet of Things (IoT) sensor set 125), and network module 115. Remote server 104 includes remote database 130. The public cloud 105 includes a gateway 140 , a cloud coordination module 141 , a host physical machine set 142 , a virtual machine set 143 , and a container set 144 .

[0023] Computer 101 may take the form of a desktop computer, laptop computer, tablet computer, smart phone, smart watch or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device now known or developed in the future that is capable of running programs, accessing a network, or querying a database such as remote database 130. As is well known in the art of computer technology, and depending on the technology, the performance of computer-implemented methods may be distributed among multiple computers and / or among multiple locations. On the other hand, in this presentation of computing environment 100, the detailed discussion focuses on a single computer, particularly computer 101, to keep the presentation as simple as possible. Computer 101 may be located in the cloud, even though it is not yet fully understood. Figure 1 1 is not shown in the cloud, on the other hand, computer 101 need not be in the cloud except to any extent that can be positively indicated.

[0024] Processor set 110 includes one or more computer processors of any type known now or to be developed in the future. Processing circuit 120 may be distributed over multiple packages, such as multiple cooperating integrated circuit chips. Processing circuit 120 may implement multiple processor threads and / or multiple processor cores. Cache 121 is a memory located in the processor chip package and is typically used for data or code that should be quickly accessed by threads or cores running on processor set 110. Cache memory is typically organized into multiple levels based on relative proximity to the processing circuit. Alternatively, some or all of the caches of the processor set may be located "off chip". In some computing environments, processor set 110 may be designed to work with qubits and perform quantum computing.

[0025] Computer-readable program instructions are typically loaded onto the computer 101 to cause the processor set 110 of the computer 101 to perform a series of operating steps to implement a computer-implemented method, so that the instructions so executed will instantiate the method specified in the flowchart and / or narrative description of the computer-implemented method included in this document (collectively referred to as the "method of the present invention"). These computer-readable program instructions are stored in various types of computer-readable storage media, such as cache 121 and other storage media discussed below. The program instructions and related data are accessed by the processor set 110 to control and direct the execution of the computer-implemented method. In the computing environment 100, at least some of the instructions for performing the method of the present invention may be stored in a block 200 in a permanent storage device 113.

[0026] The communication fabric 111 is the signal conduction paths that allow the various components of the computer 101 to communicate with each other. Typically, the fabric is made up of switches and conductive paths, such as those that make up a bus, a bridge, physical input / output ports, etc. Other types of signal communication paths may be used, such as fiber optic communication paths and / or wireless communication paths.

[0027] The volatile memory 112 is any type of volatile memory now known or developed in the future. Examples include dynamic random access memory (RAM) or static RAM. Typically, the volatile memory 112 is characterized by random access, but this is not required unless affirmatively indicated. In the computer 101, the volatile memory 112 is located in a single package and is internal to the computer 101, but, alternatively or additionally, the volatile memory can be distributed in multiple packages and / or located externally relative to the computer 101.

[0028] Permanent storage 113 is any form of non-volatile storage for computers known now or developed in the future. The non-volatility of the memory means that the stored data is maintained regardless of whether power is supplied to the computer 101 and / or directly to the permanent storage 113. Permanent storage 113 can be a read-only memory (ROM), but usually at least a portion of permanent storage allows the writing of data, the deletion of data, and the rewriting of data. Some common forms of permanent storage include disks and solid-state storage devices. Operating system 122 can take several forms, such as various known proprietary operating systems or operating systems of the open source portable operating system interface type using a kernel. The code included in block 200 generally includes at least some computer codes involved in executing the method of the present invention.

[0029] The peripheral device set 114 includes a set of peripheral devices of the computer 101. The data communication connection between the peripheral device 114 and other components of the computer 101 can be implemented in various ways, such as a Bluetooth connection, a near field communication (NFC) connection, a connection made by a cable (such as a universal serial bus (USB) type cable), a plug-in type connection (e.g., a secure digital (SD) card), a connection made through a local area communication network, and even a connection made through a wide area network such as the Internet. In various embodiments, the UI device set 123 may include components such as display screens, speakers, microphones, wearable devices (such as goggles and smart watches), keyboards, mice, printers, touchpads, game controllers, and tactile devices. The storage device 124 is an external storage device, such as an external hard drive, or a pluggable storage device, such as an SD card. The storage device 124 can be permanent and / or volatile. In some embodiments, the storage device 124 can take the form of a quantum computing storage device for storing data in the form of quantum bits. In embodiments where the computer 101 needs to have a large amount of storage (e.g., where the computer 101 locally stores and manages a large database), the storage may be provided by a peripheral storage device designed to store very large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 125 consists of sensors that can be used in IoT applications. For example, one sensor may be a thermometer, while another sensor may be a motion detector.

[0030] The network module 115 is a collection of computer software, hardware, and firmware that allows the computer 101 to communicate with other computers via the WAN 102. The network module 115 may include hardware such as a modem or a Wi-Fi signal transceiver, software for packetizing and / or depacketizing data transmitted over a communication network, and / or web browser software for transmitting data over the Internet. In some embodiments, the network control function and the network forwarding function of the network module 115 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software defined networks (SDN)), the control function and the forwarding function of the network module 115 are performed on physically separated devices, so that the control function manages several different network hardware devices. Computer-readable program instructions for executing a computer-implemented method can typically be downloaded to the computer 101 from an external computer or an external storage device via a network adapter card or a network interface included in the network module 115.

[0031] WAN 102 is any wide area network (e.g., the Internet) capable of transmitting computer data over non-local distances by any technology now known or developed in the future for transmitting computer data. In some embodiments, WAN 102 may be replaced and / or supplemented by a local area network (LAN) designed to transmit data between devices located in a local area (e.g., a Wi-Fi network). WANs and / or LANs typically include computer hardware such as copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and edge servers.

[0032] End-user device (EUD) 103 is any computer system used and controlled by an end-user (e.g., a customer of an enterprise operating computer 101), and may take any of the forms discussed above in connection with computer 101. EUD 103 typically receives useful and usable data from the operation of computer 101. For example, in the hypothetical case where computer 101 is designed to provide recommendations to an end-user, the recommendations would typically be transmitted from network module 115 of computer 101 to EUD 103 via WAN 102. In this manner, EUD 103 may display or otherwise present the recommendations to the end-user. In some embodiments, EUD 103 may be a client device, such as a thin client, a heavy client, a mainframe computer, a desktop computer, etc.

[0033] Remote server 104 is any computer system that provides at least some data and / or functionality to computer 101. Remote server 104 may be controlled and used by the same entity that operates computer 101. Remote server 104 represents a machine that collects and stores useful and usable data for use by other computers, such as computer 101. For example, in the hypothetical case where computer 101 is designed and programmed to provide recommendations based on historical data, the historical data may be provided to computer 101 from remote database 130 of remote server 104.

[0034] The public cloud 105 is any computer system available for use by multiple entities that provides on-demand availability of computer system resources and / or other computer capabilities, particularly data storage (cloud storage) and computing capabilities, without direct active management by users. Cloud computing typically utilizes the sharing of resources to achieve consistency and economy of scale. The direct and active management of the computing resources of the public cloud 105 is performed by computer hardware and / or software of the cloud coordination module 141. The computing resources provided by the public cloud 105 are typically implemented by virtual computing environments running on various computers that constitute the host physical machine set 142, which is the universe of physical computers in and / or available for the public cloud 105. Virtual computing environments (VCEs) typically take the form of virtual machines from a virtual machine set 143 and / or containers from a container set 144. It should be understood that these VCEs can be stored as images and can be transferred between various physical machine hosts as images or after instantiation of the VCEs. Cloud orchestration module 141 manages the transfer and storage of images, deploys new instantiations of VCEs, and manages active instantiations of VCE deployments. Gateway 140 is a collection of computer software, hardware, and firmware that allows public cloud 105 to communicate over WAN 102 .

[0035] Some further explanation of a virtualized computing environment (VCE) will now be provided. A VCE can be stored as an "image". A new active instance of the VCE can be instantiated from the image. Two common types of VCEs are virtual machines and containers. Containers are VCEs that use operating system-level virtualization. This refers to an operating system feature in which the kernel allows the existence of multiple isolated user space instances, called containers. From the perspective of the programs running in them, these isolated user space instances typically behave like actual computers. Computer programs running on a normal operating system can utilize all of the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running within a container can only use the contents of the container and the devices assigned to the container, a feature known as containerization.

[0036] The private cloud 106 is similar to the public cloud 105, except that the computing resources are only available to a single enterprise. Although the private cloud 106 is depicted as communicating with the WAN 102, in other embodiments, the private cloud can be completely disconnected from the Internet and can only be accessed through a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types), typically implemented by different vendors. Each of the multiple clouds remains an independent and discrete entity, but the larger hybrid cloud architecture is bound together by standardized or proprietary technologies that enable coordination, management, and / or data / application portability between the multiple constituent clouds. In this embodiment, the public cloud 105 and the private cloud 106 are both part of a larger hybrid cloud.

[0037] Figure 2 2 shows a flowchart for transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. Initially, various inputs 210 may be provided to the transformation code 200 to generate microservices for the application. As an example, the input may include the code of the application to be transformed, various documents (e.g., instructions for use or instruction documents, test documents, etc.), and / or a description of the user's intent for transformation. The description is preferably in natural language, and may include any form to provide user intent or guidance for performing the transformation (e.g., keywords, text, project description, reference model, business or other language, instructions for use or application description documents, etc.). The user's intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functions, specific software products, the number of resulting microservices and / or software products for analysis, parameters, etc.). In other words, the user's intent indicates the way in which the user expects the application to be divided or mapped to microservices (e.g., a specific number of microservices to be generated, certain modules to be considered or excluded, desired functions, etc.).

[0038] The transformation code 200 includes an analysis module 220 and a microservice recommender 230. The analysis module 220 includes a program / data analysis module 222 and an intent analysis module 224. The program / data analysis module analyzes the code of the application to be transformed to provide various information (e.g., exposed services, service entry points (SEPs), packages, names, comments, variables, data definition languages ​​(DDLs) or database references in the application code, plain old Java objects, interfaces, tables, labels, columns, module or program names, method names, summaries, etc.). The intent analysis module employs natural language processing (NLP) and / or natural language understanding (NLU) techniques to determine the functionality of the microservice based on the description of the user's intent. The intent analysis module identifies one or more modules of the application to be used as seed modules for clustering by the microservice recommender 230. However, any software artifact of the application can be utilized. The seed module basically indicates the center of the corresponding cluster for clustering. The intent analysis module can interact with the user to confirm the mapping of software artifacts to user intent and / or finalize the functionality or software artifacts to be considered for transformation.

[0039] The microservice recommender 230 uses the seed module as the center of the corresponding cluster and generates clusters with members (or application modules) that are similar or close in functionality to the seed module. In other words, each cluster corresponds to a microservice whose functionality is indicated by the members (or modules) that belong to the cluster. When an application module or program is assigned to two or more clusters, various metrics may be used to determine cluster membership (e.g., highest probability or confidence, etc.). As an example, the microservice recommender 230 may generate a cluster 242 (e.g., corresponding to a microservice such as Figure 2 1) and clusters 244 (e.g., corresponding to Figure 2 2). The functionality of the cluster members indicates the functionality of the corresponding microservices. The microservice recommender can interact with the user to verify the microservice recommendation, and / or provide iterative design by enabling the user to move or rearrange entities (e.g., microservices, functions, members within a cluster, etc.).

[0040] The transformation code 200 can generate a code stub 250 (e.g., a code template or framework) of the microservice to accelerate the generation of the code. Alternatively, the transformation code can automatically generate the code of the microservice based on the functions or codes of the modules belonging to the cluster. The generated microservice can be deployed to a cloud or other distributed computing environment and executed. The microservice represents a transformed version suitable for a cloud or other distributed computing environment. Therefore, embodiments of the present invention improve the participation of users in the conversion or reconstruction process.

[0041] The embodiment of the present invention reduces the iteration of design completion, and can generate a microservice project summary and a functional label for each microservice. In addition, inactive code and services of the application can be excluded from reconstruction or transformation, and test instances can be generated and prioritized.

[0042] Figure 3 2 is a block diagram of an intent analysis module 224 according to an embodiment of the present invention. The intent analysis module uses natural language processing (NLP) and / or natural language understanding (NLU) technology to determine the functionality of a microservice based on a description of a user's intent. The intent analysis module identifies one or more modules of an application to be transformed to serve as seed modules for clustering by the microservice recommender 230. However, any software artifact of an application can be used as a seed for clustering. The seed module basically indicates the center or reference point of the corresponding cluster.

[0043] The intent analysis module 224 includes a sentence classifier 310, a function identifier 320, a deduplication module 330, a service entry point (SEP) detector 340, and a mapper 350. The sentence classifier 310 analyzes the description of the user's intent to determine sentences indicating functions and / or other information (e.g., the number of microservices, the specified modules or services, etc.) for transformation. The analysis can employ various conventional or other natural language processing (NLP) and / or natural language understanding (NLU) techniques. These techniques may include various functions such as entity extraction (e.g., identification of entities), relationship extraction (e.g., identification of relationships between entities, such as parent-child, containment, is, etc.), semantic analysis (e.g., meaning of terms, etc.), and / or part-of-speech (POS) tagging or recognition. The technology can annotate data with various information (e.g., part-of-speech (POS), relationships, meaning, etc.) for processing.

[0044] The sentence classifier 310 can be a rule-based classifier, where the rules indicate specific text and corresponding classifications. For example, the rules can specify certain keywords and corresponding synonym expansions (e.g., application / app / system, support / provide / expose, function / module / feature, etc.), which indicate the presence of functions and / or other information within the sentence (e.g., the number of microservices, specified modules or services, etc.). In addition, the sentence classifier can identify hierarchical relationships within a sentence based on rules and / or NLP / NLU techniques (e.g., rules can indicate relationships between keywords, etc.).

[0045] Sentence classifier 310 can alternatively use a machine learning model to perform classification. The sentence classifier can also receive (or download) code and corresponding documents (e.g., instruction documents, etc.), and annotate the code and documents (e.g., via NLP / NLU technology) to generate a learning corpus (or training data) for the machine learning model. Any conventional or other machine learning model (e.g., mathematics / statistics, classifiers, feedforward, recursive or other neural networks, etc.) can be used. For example, a neural network can include an input layer, one or more intermediate layers (e.g., including any hidden layers) and an output layer. Each layer includes one or more neurons, wherein the input layer neurons receive input (e.g., sentences, feature vectors, etc.) and can be associated with weight values. The neurons of the intermediate layer and the output layer are connected to one or more neurons of the previous layer, and receive the output of the connected neurons of the previous layer as input. Each connection is associated with a weight value, and each neuron generates an output based on a weighted combination of the inputs to the neuron. The output of the neuron can also be based on the bias value of certain types of neural networks (e.g., recursive types of neural networks).

[0046] The weight (and bias) values ​​can be adjusted based on various training techniques. For example, a sentence (or a feature vector of a sentence) can be used as an input and a corresponding classification (e.g., the presence or absence of a function) can be used as an output to train a neural network. The feature vector can include any feature or characteristic of a sentence (e.g., word count, character count, word frequency, etc.), wherein the neural network attempts to generate the output (or classification) provided and uses the error from the output (e.g., the difference between the generated output and the known output) to adjust the weight (and bias) value (e.g., via back propagation or other training techniques). The output layer of the neural network indicates the classification of the input data. As an example, the output layer neurons can indicate a specific classification (e.g., corresponding to the presence or absence of a function and / or other information). In addition, the output layer neurons can be associated with different categories and indicate the probability that the input data belongs to a category. The class associated with the highest probability is preferably selected as the classification of the input (e.g., the presence or absence of a function and / or other information). The description of the user's intention can be parsed into a sentence provided to the machine learning model. The machine learning model may receive sentence text or feature vectors and produce a classification indicating the presence or absence of functionality and / or other information (e.g., number of microservices, specified modules or services, etc.) for the corresponding sentence.

[0047] Function identifier 320 identifies functions indicated in the description of user intent by analyzing sentences classified as containing functions by sentence classifier 310. Function identifier can be rule-based, where rules indicate certain text or text patterns and corresponding classifications. For example, a rule can indicate certain combinations of verbs and nouns to identify functions (e.g., view portfolio, execute trades, manage accounts, etc.). These patterns can be identified based on annotations provided by the above-mentioned NLP / NLU techniques.

[0048] Function identifier 320 may alternatively use a machine learning model to perform classification. Function identifiers may use annotation data and learn over time. Any conventional or other machine learning model (e.g., mathematical / statistical, classifier, feedforward, recursive or other neural network, etc.) may be used. For example, the function identifier may use a neural network as described above. The neural network may be trained with a sentence (or a feature vector of a sentence) as input and with a corresponding known classification (e.g., function) as output. The feature vector may include any feature or characteristic of a sentence (e.g., word count, character count, word frequency, etc.). The output layer of the neural network indicates the classification of the input data. As an example, the output layer neurons may indicate a specific classification (e.g., corresponding to a function). In addition, the output layer neurons may be associated with different categories (or functions) and indicate the probability that the input data belongs to a category. The category associated with the highest probability (e.g., based on exceeding or otherwise satisfying a threshold) is preferably selected as the classification (e.g., function) of the input. The machine learning model may be trained to identify functions (or words) that can be used directly as seeds for clustering. Sentences containing functions are provided to the machine learning model. The machine learning model may receive sentence text or feature vectors and generate one or more classifications indicating the function of the corresponding sentence.

[0049] The deduplication module 330 analyzes the identified functions and resolves the duplications based on synonyms or central domain knowledge. The SEP detector 340 identifies services and service entry points (SEPs) in the application code (e.g., how a client accesses a service such as a caller, etc.). The SEP detector can use any conventional or other static analysis tools to identify services exposed through configuration files or annotations in the code. In addition, the SEP detector can analyze runtime logs to detect service entry points (SEPs).

[0050] For example, the service entry point (SEP) can be detected in the servlet code by searching for the servlet class and identifying the service implementation reachable from the servlet class. The service entry point (SEP) of the Java API for RESTful Web Services (JAX-RS) can be detected by searching for classes and methods with JAX-RS annotations. With respect to Java Server Facet (JSF), the service entry point (SEP) can be detected by extracting the service expression from the view template and finding the class and method that implements the service. The service entry point (SEP) for SPRING can be detected by searching for a class with "controller" and identifying the service implementation reachable from the class, and also finding the REST path as the service entry name. With respect to STRUTS, the service entry point (SEP) can be detected by searching for a configuration file (e.g., Struts-config.xml) and identifying the service implementation and name from the action tag. The service entry point (SEP) of the Java API for XML Web Services (JAX-WS) can be detected by searching for a class with "WebService" and identifying the service implementation reachable from the class.

[0051] The mapper 350 maps the functions from the user intent to the software artifacts of the application identified by the SEP detector 340, and can group the software artifacts for user confirmation about the functions. The mapper can use various information identified by the program / data analysis module 222 (e.g., exposed services, service entry points (SEPs), packages, names, annotations, variables, database references in data definition language (DDL) or application code, plain old Java objects (POJOs), interfaces, tables, labels, columns, module or program names, method names, summaries, etc.) to perform the mapping. The mapping can use a match or partial match of the name or label of the function to the information identified by the program / data analysis module 222 to identify one or more software artifacts (e.g., modules or programs) corresponding to the function. The mapping can be limited based on the information in the user intent (e.g., limited to specified modules or services, etc.).

[0052] The mapping may result in a software product (e.g., a module or program) of the application not being mapped to a function. For example, a match or partial match may not produce a mapping of a software product to a function (e.g., based on a name or feature, etc.), but the software product may be associated or connected to a software product mapped to a function. In this case, the software product is associated with the function by the microservice recommender 230 during clustering (e.g., unmapped software products are clustered together with mapped software products, etc.). As a further example, a match or partial match may not produce a mapping of a software product to a function because the attributes (e.g., name or feature, etc.) are significantly different from the function. In this case, the software product may indicate a new function that is missing from the description of the user's intent or be associated with the new function. This can be determined based on the above-mentioned natural language processing (NLP) and / or natural language understanding technology (NLU) (e.g., annotations and rules for determining functions based on names or other attributes).

[0053] The mapper 350 can identify missing functionality relative to the description of the user's intent. In other words, there may be additional functionality in the application code (e.g., a module or program) that may not yet be mapped to functionality within the description of the user's intent as described above. When functionality is missing, the mapper 350 can present and prompt the user to select the missing functionality to be included in the transformation. The user can also provide a label for the missing functionality.

[0054] In addition, the mapper 350 can interact with the user to confirm the mapping of software products (e.g., modules or programs) to the user's intent. When requesting user input, the mapper 350 can present the mapping of software products to the functions of the user's intent and enable the user to confirm or modify the mapping (e.g., add or remove software products in the mapping, etc.).

[0055] The mapped software artifacts (e.g., modules or programs corresponding to services or service entry points (SEPs)) are provided from the analysis module 220 to the microservice recommender 230 to perform clustering. The mapped software artifacts can be filtered by the mapper 350 based on information in the user intent (e.g., number of microservices, specified modules or services, etc.). The software artifacts (e.g., modules or programs) are used as centers or reference points for corresponding clusters, and clustering identifies or assigns the remaining modules or programs of the application to clusters based on proximity to those cluster centers. Each cluster corresponds to a microservice with cluster members (or application modules or programs), which indicate the functionality of the cluster. When application modules or programs are assigned to two or more clusters, various metrics can be used to determine cluster membership (e.g., highest probability or confidence, etc.).

[0056] The intention analysis module 224 may alternatively employ a machine learning model to receive a description of the user's intention and determine the mapped software product (e.g., a module or program). Any conventional or other machine learning model (e.g., mathematical / statistical, classifier, feedforward, recursive or other neural network, etc.) may be employed. For example, the intention analysis module may employ a neural network as described above. The neural network may be trained using various descriptions of the user's intention (or a feature vector of the user's intention) as input and corresponding known classifications (e.g., corresponding to software products of the application) as output. The feature vector may include any features or characteristics (e.g., word count, character count, word frequency, etc.) of the description of the user's intention. The output layer of the neural network indicates the classification of the input data. As an example, the output layer neurons may indicate a specific classification (e.g., corresponding to a set of software products, etc.). In addition, the output layer neurons may be associated with different categories (or software products) and indicate the probability that the input data belongs to a category. The class associated with the highest probability (e.g., higher than or otherwise meeting a threshold) is preferably selected as the classification mapped to the input (e.g., software product). A description of the user's intention may be provided to the machine learning model. A machine learning model may receive a description or feature vector and produce a classification of a software artifact indicative of a corresponding user intent.

[0057] Figure 4 4 is a process flow chart of a method 400 for transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. Initially, at operation 405, various inputs are received by the transformation code 200 to generate microservices for the application. As an example, the input may include the code of the application to be transformed, various documents (e.g., instructions or instruction documents, test documents, etc.), and / or a description of the user intent for the transformation. The description is preferably in natural language and may include any form to provide user intent or guidance for performing the transformation (e.g., keywords, text, project descriptions, reference models, business or other languages, etc.). The user intent may include any desired parameters or characteristics for generating the resulting microservice (e.g., functionality, specific software products, the number of resulting microservices and / or software products for analysis, parameters, etc.).

[0058] At operation 410, the analysis module 220 identifies functions within the description of the user's intent. The intent analysis module 224 of the analysis module parses the description of the user's intent and determines the functions within the sentences of the description in substantially the same manner as described above. For example, the intent analysis module identifies sentences containing functions and analyzes these sentences to extract the functions. This can be achieved by using natural language processing (NLP) and / or natural language understanding (NLU), rules and / or machine learning in substantially the same manner as described above.

[0059] In operation 415, when certain (or any) functions are not identified within the description of the user intent determined by the intent analysis module 224, in operation 420, the user may be prompted to input or indicate a function (e.g., prompting the user to specify the functions (e.g., as comma-delimited text, etc.), highlighting text from a description related to the functions, etc.).

[0060] In operation 425, the intent analysis module 224 maps the software artifacts (e.g., modules or programs, etc.) of the application to the determined functions. The program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be transformed to provide various information (e.g., exposed services, service entry points (SEPs), packages, names, comments, variables, data definition languages ​​(DDLs) or database references in the application code, plain old Java objects (POJOs), interfaces, tables, labels, columns, module or program names, method names, summaries, etc.). The mapper 350 of the intent analysis module can use the information from the program / data analysis module 222 to perform mapping in substantially the same manner as described above. For example, the mapping can use a match or partial match of the name or label of the function with the information identified by the program / data analysis module 222 to identify one or more software artifacts (e.g., modules or programs) of the application corresponding to the function.

[0061] At operation 430, the mapper 350 may identify missing functions. In other words, there may be additional functions in the application code (e.g., a module) that may not yet be mapped to functions within the description of the user's intent. This may be performed in substantially the same manner as described above. When functions are missing, the mapper 350 may present and prompt the user to select the missing functions to include in the transformation at operation 435. The user may also provide a label for the missing functions.

[0062] At operation 440, the mapper 350 identifies one or more software artifacts (e.g., modules or programs) of the application to serve as seed modules for clustering by the microservice recommender 230. The mapped software artifacts can be provided as seed modules, or the mapped software artifacts can be filtered based on user intent. For example, the user intent can specify a specific module and / or number of modules of the application to be processed. The seed module basically indicates a center or reference point for a corresponding cluster.

[0063] At operation 445, the mapper 350 may interact with the user to confirm the mapping of software artifacts (e.g., modules or programs) to the user's intent. When requesting user input, at operation 450, the mapper 350 may present the mapping of software artifacts to the user's intended functionality and enable the user to confirm or modify the mapping (e.g., add or remove software artifacts from the mapping, etc.).

[0064] In operation 455, the microservice recommender 230 uses the seed module to perform clustering and determine the clusters. The seed module is used as the center or reference point of the corresponding cluster, and the clustering produces clusters with members (or application modules or programs) that are similar or close to the seed module functions. In other words, each cluster corresponds to a microservice, and its function is indicated by the members (or application modules or programs) belonging to the cluster. When an application module or program is assigned to two or more clusters, various metrics can be used to determine cluster membership (e.g., highest probability or confidence, etc.).

[0065] Clustering can be performed using any conventional or other clustering techniques (e.g., K-means clustering, hierarchical clustering, etc.). Clustering can be performed using an unsupervised machine learning model based on a seed software product (e.g., a module or program), information determined for the application, and a description of the user's intent. Cluster the software products (e.g., modules or programs) of the application based on the features of the information of the application and the description of the user's intent. In other words, the clustered software products (e.g., modules or programs) are similar in nature and function. Features can be used to form a feature vector for the corresponding software product (e.g., module or program). The feature vector includes one or more vector elements, each of which includes a value for a corresponding feature. The elements or dimensions of the feature vector define a feature space for clustering. Features can include any desired features or characteristics of a software product (e.g., type, name, code features, entry points, etc.).

[0066] Software artifacts (e.g., modules or programs) are clustered by an unsupervised machine learning model based on features of descriptions of application information and user intent. The unsupervised machine learning model performs cluster analysis to group software artifacts of applications that have not been labeled, classified, or categorized. Cluster analysis identifies common features. The unsupervised machine learning model preferably employs K-means clustering, however, any conventional or other clustering technique (e.g., hierarchical clustering, etc.) may be used to cluster software artifacts.

[0067] The unsupervised machine learning model clusters software artifacts in feature space by processing feature vectors of software artifacts (e.g., modules or programs) to form clusters of software artifacts. The formed clusters are each associated with a corresponding microservice, and the functions of the members of the cluster indicate the functions of the corresponding microservice. Clustering can be performed to produce any number of clusters, each cluster associated with a microservice. Different software artifacts from the mapper 350 form reference points for forming clusters of K-means or other clustering techniques. The resulting clusters contain members with similar functions to the reference software artifacts.

[0068] Unsupervised machine learning models can be implemented by any conventional or other machine learning models (e.g., mathematical / statistical models, classifiers, feedforward, recursive or other neural networks, etc.). For example, a neural network may include an input layer, one or more intermediate layers (e.g., including any hidden layers), and an output layer. Each layer includes one or more neurons, wherein the input layer neurons receive inputs (e.g., feature vectors) and may be associated with weight values. The neurons of the intermediate and output layers are connected to one or more neurons of the previous layer and receive the outputs of the connected neurons of the previous layer as inputs. Each connection is associated with a weight value, and each neuron generates an output based on a weighted combination of the inputs to the neuron. The output of a neuron may also be based on a bias value of a certain type of neural network (e.g., a recursive type of neural network).

[0069] The weight (and bias) values ​​can be adjusted based on various training techniques. For example, an unsupervised machine learning model can be trained with a training set of unlabeled features and / or new input features (e.g., application features, user intent features, etc.), where the neural network attempts to generate the provided data and uses the error from the output (e.g., the difference between the input and the output) to adjust the weight (and bias) values. The output layer of the neural network indicates the clustering of the input data. As an example, the output layer neurons can indicate a specific cluster or an identifier of a specific cluster. In addition, the output layer neurons can be associated with different clusters and indicate the probability (or confidence) that the input data belongs to the associated cluster. The cluster associated with the highest probability is preferably selected for the input data.

[0070] At operation 460, the microservice recommender 230 may interact with the user. When user input is requested, at operation 465, the user may verify the microservice recommendation and / or perform an iterative design by moving or rearranging entities (e.g., microservices, functions, members within a cluster, etc.).

[0071] At operation 470, the transformation code 200 can generate a code stub 250 (e.g., a code template or skeleton) for the microservice. The code stub preferably includes some introductory code for the microservice (e.g., class or other header or definition, variable definition, library access, etc.), and enables a user to enter code in the body to perform the function. Alternatively, the transformation code 200 can automatically generate code for the microservice based on the functions or code of the software artifacts (e.g., modules or programs) belonging to the cluster. The generated microservice is deployed to a cloud or other distributed computing environment and executed at operation 475. The microservice represents a transformed version of an application suitable for a cloud or other distributed computing environment.

[0072] Figure 52 is an illustration of an example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. Initially, various inputs may be provided to the transformation code 200 to generate microservices for the application. As an example, the input may include the code of the application to be transformed, and a description of the user intent 510 for the transformation. The input may also include various documents (e.g., instructions for use or instruction documents, test documents, etc.). The description of the user intent is preferably in natural language, and may include any form of providing user intent or guidance for performing the transformation (e.g., keywords, text, project description, reference model, business or other language, etc.). The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functions, specific software products, the number of resulting microservices and / or software products for analysis, parameters, etc.). In other words, the user intent indicates the way in which the user expects the application to be divided or mapped to microservices (e.g., a specific number of microservices to be generated, certain modules to be considered or excluded, desired functions, etc.). In this example case, the description of the user intent indicates the functions of logging in, viewing a portfolio, obtaining stock quotes, and transferring stocks.

[0073] The intent analysis module 224 of the analysis module 220 identifies functions within the user intent description 510 in substantially the same manner as described above. In this case, the intent analysis module parses the description of the user intent and determines a sentence containing an application function. The intent analysis module 224 identifies at least four functions mentioned in the determined sentence (e.g., authentication (corresponding to "login"), portfolio management (corresponding to "view portfolio"), stock quote lookup (corresponding to "stock quote"), and trading stocks (corresponding to "transfer stocks"), and when some (or any) functions are not identified, the user can be prompted to specify a function (e.g., specify a function, highlight text from a description or other input, etc.).

[0074] The program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be transformed to provide various information as described above (e.g., exposed services, service entry points (SEPs), packages, names, comments, variables, data definition language (DDL) or database references in the application code, plain old Java objects (POJOs), interfaces, tables, labels, columns, module or program names, method names, summaries, etc.). The mapper 350 of the intent analysis module utilizes the application information from the program / data analysis module 222 and maps the software artifacts 520 (e.g., modules, such as Figure 5The mapper 350 may map the MOD 1-MOD4 shown in FIG. 1 to the identified functionality. The mapper 350 may identify additional functionality in the application that is beyond the functionality indicated in the description of the user's intent. In this case, the user is prompted to select from the missing functionality to include in the transformation in substantially the same manner as described above. The mapper 350 may include software artifacts (e.g., such as Figure 5 MOD 5) as shown in the figure.

[0075] Corresponding to functional software artifacts 520 (e.g., Figure 5 The microservice recommender 230 uses the application information from the program / data analysis module 222 and the software artifacts 520 (e.g., Figure 5 The modules MOD 1 - MOD 5) shown serve as anchors or centers for clusters corresponding to microservices, dividing the application into five microservices (corresponding to five functions).

[0076] Figure 6 is an illustration of another example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. Initially, various inputs may be provided to the transformation code 200 to generate microservices for the application. As an example, the input may include the code of the application to be transformed, and a description of the user intent 610 for the transformation. The input may also include various documents (e.g., instructions or instruction documents, test documents, etc.). The description is preferably in natural language, and may include any form to provide user intent or guidance for performing the transformation (e.g., keywords, text, project description, reference model, business or other language, etc.). The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functions, specific software products, the number of resulting microservices and / or software products for analysis, parameters, etc.). In other words, the user intent indicates how the user expects the application to be divided or mapped into microservices (e.g., a specific number of microservices to be generated, certain modules to be considered or excluded, desired functions, etc.). In this example case, the description of the user intent indicates functions (e.g., a project ingestion process), specific services (e.g., Figure 6 SER 1-SER10 shown) and the number of specific services to focus on (e.g., the first three of ten offered services).

[0077] The intent analysis module 224 of the analysis module 220 identifies functions and services within the user intent description 610 in substantially the same manner as described above. In this case, the intent analysis module parses the description of the user intent and determines the functions within the statement of the user intent and the specific services (e.g., SER 1-SER 3) to be processed.

[0078] The program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be transformed to provide various information, including data related to a specific module (e.g., exposed services, service entry points (SEPs), packages, names, comments, variables, data definition language (DDL) or database references in application code, plain old Java objects (POJOs), interfaces, tables, labels, columns, module or program names, method names, summaries, etc.), as described above. The mapper 350 of the intent analysis module 224 utilizes the application information from the program / data analysis module 222 and maps the software artifacts 630 of the application to specific services.

[0079] Software artifacts 630 related to a particular service (e.g., Figure 6 Modules MOD 1-MOD 3 shown are provided to a microservice recommender 230 to generate recommended or candidate microservices in substantially the same manner as described above. In this case, the microservice recommender 230 uses application information from the program / data analysis module 222 and software artifacts 630 (e.g., such as the software artifacts 630) that serve as anchors or centers of clusters corresponding to microservices. Figure 6 Modules MOD 1-MOD 3) shown in the figure divide the application into three microservices (e.g., corresponding to specific services in the user's intent). The microservices can be presented on the user interface. For example, the microservices can be presented in the form of a graph 640. The graph includes nodes 642 corresponding to the microservices and edges 644 connecting the nodes 642 to indicate the relationship or connectivity between the microservices.

[0080] Figure 72 is a diagram of another example scenario of transforming an application into a microservice architecture based on user intent according to an embodiment of the present invention. Initially, various inputs may be provided to the transformation code 200 to generate microservices for the application. As an example, the input may include the code of the application to be transformed, and a description of the user intent 710 for the transformation. The input may also include various documents (e.g., instructions or instruction documents, test documents, etc.). The description is preferably in natural language, and may include any form to provide user intent or guidance for performing the transformation (e.g., keywords, text, project description, reference model, business or other language, etc.). The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functions, specific software products, the number of resulting microservices and / or software products for analysis, parameters, etc.). In other words, the user intent indicates the way in which the user expects the application to be divided or mapped to microservices (e.g., a specific number of microservices to be generated, certain modules to be considered or excluded, desired functions, etc.). In this example case, the description of the user intent indicates functions related to invoice and event processors.

[0081] The intent analysis module 224 of the analysis module 220 identifies functions within the user intent description 710 in substantially the same manner as described above. In this case, the intent analysis module parses the description of the user intent and determines that the initial two sentences contain information related to functions (e.g., invoice service (e.g., corresponding to "invoicing") and event processor service (e.g., corresponding to "event processor"). When some (or any) functions are not identified, the user can be prompted to specify the function (e.g., specify the function, highlight text from the description or other input, etc.).

[0082] The program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be transformed to provide various information as described above (e.g., exposed services, service entry points (SEPs), packages, names, comments, variables, data definition language (DDL) or database references in the application code, plain old Java objects (POJOs), interfaces, tables, labels, columns, module or program names, method names, summaries, etc.). The mapper 350 of the intent analysis module utilizes the application information from the program / data analysis module 222 and converts the software artifact 720 (e.g., as described above) into a program / data analysis module 222 in substantially the same manner as described above. Figure 7Modules MOD1-MODN) are shown mapped to functions. In other words, software artifact 720 is mapped to event handlers related to invoicing. Mapper 350 may identify additional functionality (e.g., service entry points (SEPs), etc.) in the application that is outside the functionality indicated in the description of the user's intent. In this case, the user is prompted to select from the missing functionality to include in the transformation in substantially the same manner as described above. Mapper 350 may include software artifacts corresponding to the selected functionality.

[0083] Corresponding to functional software artifacts 720 (e.g., Figure 7 The MOD 1-MOD N shown in FIG. 1-10 are provided to the microservice recommender 230 to generate recommended or candidate microservices 730 in substantially the same manner as described above. In this case, the microservice recommender 230 uses the application information from the program / data analysis module 222 and the software artifact 720 that is the anchor or center of the cluster corresponding to the microservice to divide the application into various microservices.

[0084] Embodiments of the present invention provide various technical and other advantages. For example, embodiments of the present invention transform applications of centralized architectures into forms for deployment and execution in distributed architectures with reduced iterations, thereby saving computational processing and resources. In addition, code can be automatically generated for microservices to reduce errors, thereby saving computational processing and resources (e.g., reduced compile time / attempts, fewer runtime errors, etc.).

[0085] In addition, machine learning models can learn complex combinations of mappings and clustering, thereby improving accuracy and reducing unnecessary processing of erroneous features. This reduces the consumption of processing and memory / storage resources, thereby improving computational performance.

[0086] Additionally, machine learning and other models can be continuously updated (or trained) for mapping or clustering based on feedback related to new user intent, selected functionality, and / or selected software artifacts. For example, missing functionality can be selected, and the system can learn (e.g., update NLP / NLU and / or machine learning models) to automatically include the selected functionality for future transformations based on similar user intent.

[0087] In addition, the software artifact may initially be mapped to a function with a lower confidence or probability. The software artifact may be mapped to another function by a user. This action may be used to update or train the machine learning model to increase the confidence of the software artifact for the new function (e.g., update or train the machine learning model to increase the probability of the software artifact for the new function, etc.).

[0088] In addition, a software artifact may be assigned to a cluster with a lower confidence or probability. A software artifact may be moved to another cluster by a user. This action may be used to update or train a machine learning model to increase the confidence of the software artifact for the new cluster (e.g., update or train a machine learning model to increase the probability of the software artifact for the new cluster, etc.).

[0089] Thus, the machine learning model can continuously evolve (or be trained) to learn further functions, mappings, and / or clustering as microservices are spawned.

[0090] It should be understood that the embodiments described above and illustrated in the accompanying drawings represent only a few of the many ways to transform an application into an implementation of a microservices architecture.

[0091] The environment of the embodiments of the present invention may include any number of computers or other processing systems (e.g., client or end-user systems, server systems, etc.) and databases or other repositories arranged in any desired manner, wherein the embodiments of the present invention may be applied to any desired type of computing environment (e.g., cloud computing, client-server, network computing, mainframes, stand-alone systems, etc.). The computers or other processing systems used in the embodiments of the present invention may be implemented by any number of any individuals or other types of computers or processing systems. These systems may include any type of monitor and input device (e.g., keyboard, mouse, voice recognition, etc.) to input and / or view information.

[0092] It should be understood that the software of the embodiments of the present invention (e.g., production code 200, analysis module 220, intent analysis module 224, microservice recommender 230, sentence classifier 310, function identifier 320, deduplication module 330, SEP detector 340, mapper 350, etc.) can be implemented in any desired computer language and can be developed by a person of ordinary skill in the computer field based on the functional descriptions contained in the specification and the flowcharts shown in the accompanying drawings. In addition, any reference herein to software that performs various functions generally refers to a computer system or processor that performs these functions under software control. The computer system of the embodiments of the present invention can optionally be implemented by any type of hardware and / or other processing circuits.

[0093] The various functions of a computer or other processing system may be distributed in any manner among any number of software and / or hardware modules or units, processing or computer systems and / or circuits, wherein the computers or processing systems may be arranged locally or remotely from one another and communicate via any appropriate communication medium (e.g., LAN, WAN, intranet, Internet, hardware lines, modem connections, wireless, etc.). For example, the functions of an embodiment of the present invention may be distributed in any manner among various end-user / client and server systems and / or any other intermediate processing devices. The software and / or algorithms described above and shown in the flow charts may be modified in any manner to achieve the functions described herein. In addition, the functions in the flow charts or descriptions may be performed in any order to achieve the desired operations.

[0094] The communication network can be implemented by any number of any type of communication networks (e.g., LAN, WAN, Internet, intranet, VPN, etc.). The computer or other processing system of the embodiment of the present invention can include any conventional or other communication equipment to communicate through the network via any conventional or other protocol. The computer or other processing system can access the network using any type of connection (e.g., wired, wireless, etc.). The local communication medium can be implemented by any suitable communication medium (e.g., local area network (LAN), hardware line, wireless link, intranet, etc.).

[0095] The system may employ any number of any conventional or other databases, data stores or storage structures (e.g., files, databases, data structures, data or other repositories, etc.) to store information. The database system may be implemented by any number of any conventional or other databases, data stores or storage structures (e.g., files, databases, data structures, data or other repositories, etc.) to store information. The database system may be included within or coupled to a server and / or client system. The database system and / or storage structures may be remote from or local to a computer or other processing system and may store any desired data.

[0096] Embodiments of the present invention may employ any number of any type of user interfaces (e.g., graphical user interfaces (GUIs), command lines, prompts, etc.) to obtain or provide information (e.g., functions, maps, clusters, etc.), wherein the interface may include any information arranged in any manner. The interface may include any number of any type of input or actuation mechanisms (e.g., buttons, icons, fields, boxes, links, etc.) arranged in any location to input / display information and initiate desired actions via any suitable input device (e.g., mouse, keyboard, etc.). Interface screens may include any suitable actuators (e.g., links, tabs, etc.) to navigate between screens in any manner.

[0097] Reports may include any information arranged in any manner, and may be configurable based on rules or other criteria to provide the desired information to a user (eg, microservices, software artifacts, etc.).

[0098] Embodiments of the present invention are not limited to the specific tasks or algorithms described above, but can be used to transform or convert any application program to any distributed computing environment.

[0099] The application can be any type (e.g., a monolithic application, etc.) for transformation to a distributed computing environment. For example, embodiments of the present invention can be used to reconfigure or optimize distributed applications into different microservices. The transformation can be used in any distributed computing environment (e.g., cloud, etc.). The application program can be divided into any number of any software or other components of a distributed computing environment. In addition, a microservice can be any software module or other component of a distributed computing environment that executes any part of the overall process (e.g., any service or service portion, any part or operation of the overall process to be performed, etc.). A software product can include any item related to the software or code of the application (e.g., a module or program of source and / or compiled code, documents, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). A module can include any part of the application code (e.g., a program, a method, a routine, a function, a data structure, data, etc.).

[0100] User intent may include any form of providing user intent or guidance for performing a transformation (eg, keywords, text, project descriptions, reference models, business or other languages, usage instructions or application description documents, etc.).

[0101] The program / data analysis module can obtain any information related to the application code (e.g., exposed services, service entry points (SEPs), packages, names, annotations, variables, data definition language (DDL) or database references in the application code, plain old Java objects (POJOs), interfaces, tables, tags, columns, module or program names, method names, summaries, etc.).

[0102] The intent analysis module may employ any conventional or other natural language processing (NLP) and / or natural language understanding (NLU) techniques to analyze user intent and extract any desired information (e.g., entity extraction (e.g., identification of entities), relationship extraction (e.g., identification of relationships between entities such as parent, child, contains, is, etc.), semantic analysis (e.g., meaning of words, etc.), part-of-speech (POS) tagging or identification, etc.). The intent analysis module may employ any conventional or other machine learning model (e.g., mathematical / statistical, classifier, feed-forward, recursive or other neural network, etc.) to extract information and / or perform mapping. The mapping may utilize any type of matching or mapping (e.g., partial matching, probabilistic matching, machine learning, etc.) to map any number of software artifacts to any number of functions. In addition, the machine learning model may be trained to recognize functions (e.g., words, module or program names, etc.) in user intent, which may be used directly as seeds for clustering. These functions may be used alone or in combination with the mapped software artifacts as seeds for clustering.

[0103] The microservice recommender can utilize any conventional or other clustering techniques (e.g., K-means clustering, hierarchical clustering, etc.), and can use any type of software artifact or function as the center or reference point of the cluster. Clustering can produce any number of clusters with any number of members or software artifacts. Software artifacts assigned to multiple different clusters can be parsed in any way (e.g., highest probability or confidence, etc.). The microservice recommender can utilize any conventional or other machine learning model (e.g., mathematical / statistical model, classifier, feedforward, recursive or other neural network, etc.).

[0104] The code for the microservice may be generated in any manner. For example, a code stub may be generated for a user to provide code for a function. Alternatively, the code (including the function) may be automatically generated in any manner. For example, the code may be generated based on the functions or code (e.g., reuse of code, generation of new or equivalent code, etc.) of software artifacts (e.g., modules or programs) belonging to the cluster.

[0105] Microservices can be deployed to any number or combination of processing devices of any cloud or other distributed computing environment and can be executed in any manner (e.g., serially, in parallel, etc.). Transforming an application into a distributed microservice enables faster processing time and saves resources because multiple processing devices are performing functions (e.g., performing at least a portion of the processing in parallel, etc.). Microservices can be deployed to a distributed computing environment for execution based on resource availability to provide improved processing time for the application's functions.

[0106] The terms used herein are only for the purpose of describing specific embodiments, rather than to limit the present invention. As used herein, the singular forms "a", "an", and "the" are intended to also include plural forms, unless the context clearly indicates otherwise. It should also be understood that the terms "comprise", "include", "contain", "have", "with", etc., when used in this specification, specify the presence of the features, integers, steps, operations, elements and / or parts, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, parts and / or combinations thereof.

[0107] The corresponding structures, materials, actions and equivalents of all means or steps plus function elements in the following claims are intended to include any structure, material or action for performing a function in combination with other claimed elements as specifically claimed. Descriptions of various embodiments of the present invention have been given for illustrative purposes, but are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope of the described embodiments. The terms used herein are selected to best explain the principles of the embodiments, practical applications or technical improvements existing on the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

Claims

1. A method for transforming an application for use in a distributed computing environment, comprising: analyzing, via at least one processor, the description of user intent to extract information for transforming the application, wherein the extracted information indicates functionality for the distributed computing environment; mapping, via the at least one processor, a plurality of software artifacts of the application to the functionality, wherein the plurality of software artifacts form different groups of software artifacts; allocating, via the at least one processor, remaining software artifacts of the application into the different groups based on the remaining software artifacts corresponding to the mapped software artifacts of the groups, wherein the different groups correspond to microservices for the distributed computing environment; and The microservices are presented, via the at least one processor, for the distributed computing environment based on the different groups.

2. The method according to claim 1, wherein: The application comprises a monolithic application, and the plurality of software artifacts comprises modules of the monolithic application.

3. The method according to claim 1, wherein: The remaining software artifacts to be distributed include: The remaining software artifacts of the application are clustered by a machine learning model based on the mapped software artifacts being used as reference points for clustering, wherein the clusters correspond to the different groups.

4. The method according to claim 1, wherein: The plurality of software artifacts mapping the application include: determining that the application has additional functionality related to the description of the user's intent; and A user selection of one or more of the additional functions is received for transforming the application.

5. The method according to claim 1, further comprising: The microservices for the distributed computing environment are generated, via the at least one processor, based on the functionality of the software artifacts within the corresponding group.

6. The method according to claim 1, wherein: The description of the user's intention includes natural language, and analyzing the description of the user's intention includes: The description of the user's intention is analyzed by natural language processing technology and a machine learning model to extract the information for transforming the application.

7. The method according to claim 1, wherein: The extracted information further indicates a number of microservices, and the number of different groups corresponds to the number of microservices.

8. A system for transforming an application for use in a distributed computing environment, comprising: one or more memories; as well as at least one processor coupled to the one or more memories, wherein the at least one processor is configured to: analyzing the description of user intent to extract information for transforming the application, wherein the extracted information indicates functionality for the distributed computing environment; mapping a plurality of software artifacts of the application to the functionality, wherein the plurality of software artifacts form different groups of software artifacts; allocating remaining software artifacts of the application into the different groups based on the remaining software artifacts corresponding to the mapped software artifacts of the groups, wherein the different groups correspond to microservices for the distributed computing environment; and Based on the different groups, the microservices are presented for the distributed computing environment.

9. The system according to claim 8, wherein: The remaining software artifacts to be distributed include: The remaining software artifacts of the application are clustered by a machine learning model based on the mapped software artifacts being used as reference points for clustering, wherein the clusters correspond to the different groups.

10. The system according to claim 8, wherein: The plurality of software artifacts mapping the application include: determining that the application has additional functionality related to the description of the user's intent; and A user selection of one or more of the additional functions is received for transforming the application.

11. The system according to claim 8, wherein: The at least one processor is further configured to: The microservices for the distributed computing environment are generated based on the functions of the software artifacts in the corresponding group.

12. The system according to claim 8, wherein: The description of the user's intention includes natural language, and analyzing the description of the user's intention includes: The description of the user's intention is analyzed by natural language processing technology and a machine learning model to extract the information for transforming the application.

13. The system according to claim 8, wherein: The extracted information further indicates a number of microservices, and the number of different groups corresponds to the number of microservices.

14. A computer program product for transforming an application for use in a distributed computing environment, the computer program product comprising one or more computer-readable storage media having program instructions stored collectively on the one or more computer-readable storage media, the program instructions being executable by at least one processor to cause the at least one processor to: The description of the user's intent is analyzed to extract information for transforming the application, wherein: The extracted information indicates functionality for the distributed computing environment; mapping a plurality of software artifacts of the application to the functionality, wherein the plurality of software artifacts form different groups of software artifacts; allocating remaining software artifacts of the application to the different groups based on the remaining software artifacts corresponding to the mapped software artifacts of the groups, wherein the different groups correspond to microservices for the distributed computing environment; and Based on the different groups, the microservices are presented for the distributed computing environment.

15. The computer program product of claim 14, wherein: The application comprises a monolithic application, and the plurality of software artifacts comprises modules of the monolithic application.

16. The computer program product of claim 14, wherein: The remaining software artifacts to be distributed include: The remaining software artifacts of the application are clustered by a machine learning model based on the mapped software artifacts being used as reference points for clustering, wherein the clusters correspond to the different groups.

17. The computer program product of claim 14, wherein: The plurality of software artifacts mapping the application include: determining that the application has additional functionality related to the description of the user's intent; and A user selection of one or more of the additional functions is received for transforming the application.

18. The computer program product of claim 14, wherein: The program instructions further cause the at least one processor to: The microservices for the distributed computing environment are generated based on the functions of the software artifacts in the corresponding group.

19. The computer program product of claim 14, wherein: The description of the user's intention includes natural language, and analyzing the description of the user's intention includes: The description of the user's intention is analyzed by natural language processing technology and a machine learning model to extract the information for transforming the application.

20. The computer program product of claim 14, wherein: The extracted information further indicates a number of microservices, and the number of different groups corresponds to the number of microservices.

Images