Method and system for transforming an application into a microservices architecture

Abstract

A system for transforming an application 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 a description of user intent and extracts information for transforming the application. The extracted information indicates functionality for the distributed computing environment. A plurality of software artifacts of the application are mapped to the functionality, and the plurality of software artifacts form distinct groups of software artifacts. Remaining software artifacts of the application are assigned to the distinct groups based on remaining software artifacts corresponding to the mapped software artifacts of a group. The distinct groups correspond to microservices for the distributed computing environment, and the microservices for the distributed computing environment are presented based on the distinct groups.

Description

[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. [Background technology]

[0002] Customers are increasingly performing application modernization to ease the management of resources (e.g., infrastructure, human resources, etc.), scale applications, reduce costs, and enrich client experiences. This is even more urgent during the transition to cloud computing environments (or microservices) because this transition forces customers, invariably, to significantly modify their applications to be cloud-enabled.

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

[0004] 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 typically a large single deployable application) to perform modernization. This is because domain-driven design (DDD) concepts are mostly applicable to portfolios of applications that are intended to be compartmentalized based on modules and corresponding teams that can support these modules. Summary of the Invention

[0005] According to one embodiment of the present invention, a system converts an application for 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 converting the application. The extracted information indicates functionality for the distributed computing environment. A plurality of software artifacts of the application are mapped to the functionality. The plurality of software artifacts form different groups of software artifacts. The remaining software artifacts of the application are assigned to the different groups based on the remaining software artifacts corresponding to the mapped software artifacts of a group. The different groups correspond to microservices for the distributed computing environment. The microservices for the distributed computing environment are presented based on the different groups. Embodiments of the present invention further include methods and computer program products for converting an application for a distributed computing environment in substantially the same manner as described above. [Brief explanation of the drawings]

[0006] Generally, like reference numbers in the various figures are used to designate like components.

[0007] [Figure 1] FIG. 1 is a schematic diagram of an exemplary computing environment according to one embodiment of the present invention.

[0008] [Figure 2] FIG. 1 is a flow diagram for transforming an application into a microservices architecture based on user intent, according to an embodiment of the present invention.

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

[0010] [Figure 4] 1 is a process flow diagram of a method for transforming an application into a microservices architecture based on user intent, according to an embodiment of the present invention.

[0011] [Figure 5] FIG. 1 is a diagram of an exemplary scenario for transforming an application into a microservices architecture based on user intent, according to an embodiment of the present invention.

[0012] [Figure 6] FIG. 10 is a diagram of another example scenario of transforming an application into a microservices architecture based on user intent, according to an embodiment of the present invention.

[0013] [Figure 7] FIG. 10 illustrates yet another example scenario of transforming an application into a microservices architecture based on user intent, according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0014] An embodiment of the present invention allows a user to specify intent (e.g., keywords, natural language text, project descriptions, reference models, etc.) for application modernization that drives the extraction or recommendation of microservices for a monolith application or code (e.g., a single-tier or non-distributed software application that combines code for user interface and data access, and typically a large, single, deployable application). However, any application can be transformed into a microservice or other distributed computing architecture. An embodiment of the present invention accepts user intent in the form of a natural language description, keywords, project description, or reference model and maps the user intent to software artifacts of the monolith application. The software artifacts may include any items related to the application's software or code (e.g., source and / or compiled code modules or programs, documentation, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). The mapped modules preferably serve as seeds for clustering application functions (or other code modules) into microservices (e.g., a collection of distributed services developed as part of a group of services that each provide an overall process).

[0015] One embodiment of the present invention allows a user (e.g., a subject matter expert (SME) or the like) to specify a modernization target state for a monolith or other application using keywords, natural language text, project descriptions, or reference models to indicate user intent. Relationships are automatically established between the user intent and the software artifacts of the monolith application (e.g., source and / or compiled code modules or programs, documentation, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). Functionality that cannot be mapped to the user intent can be discovered and dropped (or excluded) from the modernization as dead code or confirmed by the user and included for modernization. Software artifacts consistent with the user intent are prompted for on a microservice-by-microservice basis, and microservices that adhere to the user intent are generated to transform the monolith application into a microservice- (or distributed)-based architecture.

[0016] Current approaches to providing microservice recommendations for application modernization are mostly bottom-up driven, in other words, the functional boundaries recommended for microservices are discovered from the implementation structure of the application code without any external references (i.e., recommendations are inferred from the current code, tables, user interface screens, interfaces, data access objects (DAOs), service entry points (SEPs), etc.).

[0017] However, these approaches have several drawbacks. For example, a lack of standardization can lead to difficulties in managing and adhering to new standards introduced in the domain. The lack of standardization can be caused by several factors. For example, some endpoints exposed in a monolith application (e.g., related to display or transient scenarios) may be unnecessary in the target service model, and the granularity of functionality in monolith endpoints may be misleading (e.g., an endpoint in a monolith application may perform the functions of several endpoints in a user-defined model). Furthermore, the member fields of methods in a monolith application may be misleading in terms of number of members and naming. Furthermore, transactions in a monolith application may be completed entirely with a small number of method functions, making it difficult to determine ownership. In addition, microservice recommendations require end users to understand the semantics and provide a comfort level in order to assign a team to create or maintain the recommended microservices, so end users need to be involved from the beginning of the transformation or decomposition task.

[0018] Thus, one embodiment of the present invention considers user intent to map to key modules of a monolith or other application and prompts to detect scope for refactoring or transformation to recommend microservices into additional modules. An embodiment of the present invention combines keyword expansion, data structure comparison, comments, and static code analysis-based program analysis features (e.g., transactions) to compare monolith program definitions. An embodiment of the present invention maps user intent to software artifacts (e.g., modules or programs) of a monolith application, extracts the software artifacts of the monolith application to detect common functionality, and prompts and confirms scope for clustering (or recommended microservices).

[0019] Various aspects of the present disclosure are described through text, flowcharts, block diagrams of computer systems, and / or block diagrams of machine logic included in computer program product (CPP) embodiments. For any flowchart, depending on the technology involved, operations may be performed in an order different from that shown in a given flowchart. For example, again depending on the technology involved, two operations shown in successive flowchart blocks may be performed in the reverse order, as a single integrated step, simultaneously, or in an at least partially overlapping manner.

[0020] A computer program product embodiment ("CPP embodiment" or "CPP") is a term used in this disclosure to describe any set of one or more storage media (also referred to as "media") collectively included in a set of one or more storage devices that collectively contain 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. The computer-readable storage medium may be, but is not limited to, 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 diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), compact disc read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices (such as punch cards or pits / lands formed on 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, is not to be construed as storage in the form of a transitory signal per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide, light pulses passing through fiber optic cables, electrical signals communicated through wires, and / or other transmission media.As will be appreciated by those skilled in the art, data is typically moved at some infrequent time during the normal operation of a storage device, such as during access, defragmentation, or garbage collection, but the above does not make the storage device temporary, as the data is not temporary while it is stored.

[0021] Referring to FIG. 1 , computing environment 100 includes an example of an environment for the execution of at least a portion of computer code involved in performing the methodology of the present invention, such as translation code 200. In addition to container data sharing code 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 processor set 110 (including processing circuitry 120 and cache 121), communication fabric 111, volatile memory 112, persistent storage 113 (including operating system 122 and block 200 as identified above), peripheral device set 114 (including user interface (UI) device set 123, storage 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 orchestration module 141, a set of host physical machines 142, a set of virtual machines 143, and a set of containers 144.

[0022] Computer 101 may take the form of a desktop computer, a laptop computer, a tablet computer, a smartphone, a smartwatch or other wearable computer, a mainframe computer, a quantum computer, or any other form of computer or mobile device now known or later developed that is capable of executing programs, accessing a network, or querying a database, such as remote database 130. As is well understood in the art of computer technology, and depending on the technology, execution of a computer-implemented method may be distributed among multiple computers and / or among multiple locations. While in this presentation of computing environment 100, to keep the presentation as concise as possible, the detailed discussion focuses on a single computer, specifically computer 101. Although computer 101 is not depicted in the cloud in FIG. 1 , it may be located in a cloud. However, computer 101 is not required to reside within a cloud except to any extent expressly indicated.

[0023] Processor set 110 includes one or more computer processors of any type now known or later developed. Processing circuitry 120 may be distributed across multiple packages, e.g., multiple coordinated integrated circuit chips. Processing circuitry 120 may implement multiple processor threads and / or multiple processor cores. Cache 121 is memory located within the processor chip package and is typically used for data or code that should be available for fast access by threads or cores executing on processor set 110. Cache memory is typically organized into multiple levels depending on relative proximity to the processing circuitry. Alternatively, some or all caches for a processor set may be located “off-chip.” In some computing environments, processor set 110 may be designed to operate with qubits and perform quantum computing.

[0024] Computer-readable program instructions are typically loaded onto computer 101 to cause processor set 110 of computer 101 to perform a series of operational steps, thereby realizing a computer-implemented method, whereby the instructions so executed instantiate the method specified in the flowcharts and / or descriptions of the computer-implemented method contained herein (collectively referred to as the "methods 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 associated data are accessed by processor set 110 to control and direct the execution of the methods of the present invention. In computing environment 100, at least some of the instructions for executing the methods of the present invention may be stored in block 200 within persistent storage 113.

[0025] Communications fabric 111 is the signal-conducting pathway that allows various components of computer 101 to communicate with one another. Typically, this fabric is made up of switches and conductive pathways, such as those that make up buses, bridges, physical input / output ports, and the like. Other types of signal communication pathways may be used, such as fiber optic and / or wireless communication pathways.

[0026] Volatile memory 112 may be any type of volatile memory now known or later developed. Examples include dynamic type random access memory (RAM) or static type RAM. Typically, volatile memory 112 is characterized by random access, although this is not required unless expressly indicated. In computer 101, volatile memory 112 is located in a single package and is internal to computer 101; however, alternatively or additionally, volatile memory may be distributed across multiple packages and / or located external to computer 101.

[0027] Persistent storage 113 is any form of non-volatile storage for a computer, now known or later developed. The non-volatility of this storage means that stored data remains whether or not power is supplied to computer 101 and / or to persistent storage 113 directly. Persistent storage 113 may be read-only memory (ROM), but typically at least a portion of persistent storage allows data to be written, data to be deleted, and data to be rewritten. Some well-known forms of persistent storage include magnetic disks and solid-state storage devices. Operating system 122 may take several forms, such as various known proprietary operating systems or open-source Portable Operating System Interface-type operating systems that employ a kernel. The code contained in block 200 typically includes at least a portion of the computer code involved in performing the methods of the present invention.

[0028] The peripheral device set 114 includes a set of peripheral devices of the computer 101. Data communication connections between the peripheral devices and other components of the computer 101 may be implemented in various ways, such as Bluetooth connections, Near-Field Communication (NFC) connections, connections made by cable (such as a universal serial bus (USB)-type cable), insertion-type connections (e.g., a secure digital (SD) card), connections made over a local area communication network, and even connections made over a wide area network such as the Internet. In various embodiments, the UI device set 123 may include components such as a display screen, speakers, microphones, wearable devices (such as goggles and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. The storage 124 may be external storage, such as an external hard drive, or insertable storage, such as an SD card. The storage 124 may be persistent and / or volatile. In some embodiments, the storage 124 may take the form of a quantum computing storage device for storing data in the form of qubits. In embodiments where computer 101 is required to have a large amount of storage (e.g., computer 101 stores and manages large databases locally), this 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. IoT sensor set 125 consists of sensors that can be used in Internet of Things applications. For example, one sensor may be a thermometer and another sensor may be a motion detector.

[0029] Network module 115 is a collection of computer software, hardware, and firmware that enables computer 101 to communicate with other computers over WAN 102. Network module 115 may include hardware such as a modem or Wi-Fi signal transceiver, software for packetizing and / or depacketizing data for communication network transmission, and / or web browser software for communicating data over the Internet. In some embodiments, the network control and network forwarding functions of network module 115 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN)), the control and forwarding functions of network module 115 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for implementing the methods of the present invention can be downloaded to computer 101 from an external computer or external storage device, typically through a network adapter card or network interface included in network module 115.

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

[0031] End-user device (EUD) 103 is any computer system used and controlled by an end user (e.g., a customer of the enterprise operating computer 101) and may take any of the forms discussed above in connection with computer 101. EUD 103 typically receives useful and useful data from the operation of computer 101. For example, in the hypothetical case where computer 101 is designed to provide recommendations to the end user, the recommendations would typically be communicated from network module 115 of computer 101 over WAN 102 to EUD 103. In this manner, EUD 103 can 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.

[0032] 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 useful 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, then this historical data may be provided to computer 101 from remote database 130 of remote server 104.

[0033] A 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 functionality, particularly data storage (cloud storage) and computing power, without direct active management by users. Cloud computing typically leverages resource sharing to achieve coherence and economies of scale. Direct active management of public cloud 105's computing resources is performed by computer hardware and / or software in cloud orchestration module 141. The computing resources provided by public cloud 105 are typically implemented by virtual computing environments (VCEs) running on various computers that comprise host physical machine set 142, the universe of physical computers in and / or available to public cloud 105. Virtual computing environments (VCEs) typically take the form of virtual machines from virtual machine set 143 and / or containers from container set 144. It is understood that these VCEs may be stored as images and transferred among and between various physical machine hosts, either as images or after VCE instantiation. Cloud orchestration module 141 manages the transfer and storage of images, deploys new instantiations of VCE, and manages active instantiations of VCE deployments. Gateway 140 is a collection of computer software, hardware, and firmware that enables public cloud 105 to communicate over WAN 102.

[0034] Some further description of a virtualized computing environment (VCE) is now provided. A VCE can be stored as an "image." A new, active instance of a VCE can be instantiated from the image. Two well-known types of VCE are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to an operating system feature where the kernel allows for the existence of multiple isolated user space instances called containers. These isolated user space instances typically behave as actual computers from the perspective of programs running in them. A computer program running on a normal operating system can utilize all of the computer's resources, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, a program running inside a container can only use the contents of the container and of the devices assigned to the container; this feature is known as containerization.

[0035] A private cloud 106 is similar to a public cloud 105, except that the computing resources are available only for use by a single enterprise. While the private cloud 106 is shown as communicating with the WAN 102, in other embodiments, the private cloud may be completely disconnected from the Internet and accessible only through a local / private network. A hybrid cloud is a composite of multiple clouds of different types (e.g., private, community, or public cloud types), often each implemented by a different vendor. While each of the multiple clouds remains a separate, discrete entity, the larger hybrid cloud architecture is bound together by standardized or proprietary technologies that enable orchestration, management, and / or data / application portability between the constituent clouds. In this embodiment, both the public cloud 105 and the private cloud 106 are part of a larger hybrid cloud.

[0036] A flow diagram for transforming an application to a microservices architecture based on user intent, according to one embodiment of the present invention, is shown in FIG. 2. Initially, various inputs 210 may be provided to transformation code 200 to generate microservices for the application. Illustratively, the inputs may include the code of the application to be transformed, various documents (e.g., readme or instruction documents, test documents, etc.), and / or a description of the user's intent for the transformation. This description is preferably in natural language and may include any format for providing the user's intent or guidance for performing the transformation (e.g., keywords, text, project descriptions, reference models, business or other languages, readme or application description documents, etc.). The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functionality, specific software artifacts, quantities of the resulting microservices and / or software artifacts for analysis, parameters, etc.). In other words, the user intent indicates how the user wants to partition or map the application into microservices (e.g., the specific number of microservices to generate, specific modules to consider or exclude, desired functionality, etc.).

[0037] The transformed 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 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 intent analysis module employs natural language processing (NLP) and / or natural language understanding (NLU) techniques to determine functions for microservices based on a description of user 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 artifacts of the application may be utilized. The seed module essentially indicates the center of the corresponding cluster for clustering. The intent analysis module may interact with the user to confirm the mapping of software artifacts to user intent and / or to finalize the functions or software artifacts to be considered for transformation.

[0038] The microservice recommender 230 uses a seed module as the center for the corresponding cluster and generates clusters with members (or application modules) that have similar or close functionality to the seed module. In other words, each cluster corresponds to a microservice whose functionality is represented by the members (or modules) that belong to that 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, confidence, etc.). As an example, the microservice recommender 230 may generate cluster 240 including cluster 242 (e.g., corresponding to microservice 1 as displayed in FIG. 2 ) and cluster 244 (e.g., corresponding to microservice 2 as displayed in FIG. 2 ). The functionality of the members of the cluster indicates the functionality for the corresponding microservice. The microservice recommender may interact with the user to validate the microservice recommendation and / or to provide iterative design by allowing the user to move or rearrange entities (e.g., microservices, functions, members within a cluster, etc.).

[0039] The transformation code 200 may generate code stubs 250 (e.g., code templates or skeletons) for the microservices to speed code generation. Alternatively, the transformation code may automatically generate code for the microservices based on the functionality or code of modules belonging to the cluster. The generated microservices can be deployed and run in a cloud or other distributed computing environment. The microservices represent transformed versions of applications that are suitable for a cloud or other distributed computing environment. Thus, embodiments of the present invention facilitate user involvement in the transformation or refactoring process.

[0040] Embodiments of the present invention may reduce iterations for design finalization and generate a microservice project summary and functionality label for each microservice. Additionally, inactive code and services of an application may be excluded from refactoring or transformation, and test cases may be generated and prioritized.

[0041] 3 is a block diagram of intent analysis module 224 according to one embodiment of the present invention. The intent analysis module employs natural language processing (NLP) and / or natural language understanding (NLU) techniques to determine functions for a microservice based on a description of user intent. The intent analysis module identifies one or more modules of the application to be transformed for use as seed modules for clustering by microservice recommender 230. However, any software artifact of the application can be used as a seed for clustering. A seed module essentially represents a center or reference point for a corresponding cluster.

[0042] 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 user intent description to determine sentences that indicate functions and / or other information for transformation (e.g., quantity of microservices, specified modules or services, etc.). The analysis may employ various traditional 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., identifying entities), relationship extraction (e.g., identifying relationships between entities, such as parent / child, contains, is a, etc.), semantic analysis (e.g., term meaning, etc.), and / or part-of-speech (POS) tagging or identification. These techniques may annotate data with various information (e.g., parts of speech (POS), relationships, meaning, etc.) for processing.

[0043] The sentence classifier 310 may be a rule-based classifier, where rules indicate particular text and corresponding classifications. For example, rules may specify particular keywords and corresponding synonym expansions (e.g., application / app / system, supported / offered / published, function / module / feature, etc.) that indicate the presence of functionality and / or other information (e.g., quantity of microservices, specified modules or services, etc.) in the sentence. Additionally, the sentence classifier may identify hierarchical relationships within the sentence based on rules and / or NLP / NLU techniques (e.g., rules may indicate relationships between keywords, etc.).

[0044] Alternatively, the sentence classifier 310 may employ a machine learning model to perform the classification. The sentence classifier may further receive (or download) code and corresponding documentation (e.g., read-me documents, etc.) and annotate the code and documentation (e.g., via NLP / NLU techniques) to generate a learning corpus (or training data) for the machine learning model. Any traditional or other machine learning model (e.g., mathematical / statistical, classifier, feedforward, recurrent, or other neural network, etc.) may be employed. 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, where the input layer neurons receive inputs (e.g., sentences, feature vectors, etc.) and may be associated with weight values. The intermediate and output layer neurons are connected to one or more neurons in the previous layer and receive as input the outputs of the connected neurons in the previous layer. Each connection is associated with a weight value, and each neuron generates an output based on a weighted combination of the inputs to that neuron. The output of a neuron may be further based on a bias value for the particular type of neural network (e.g., a recurrent type neural network).

[0045] The weight (and bias) values ​​may be adjusted based on various training techniques. For example, a neural network may be trained using sentences (or feature vectors of sentences) as input and corresponding classifications (e.g., presence or absence of a feature) as output. The feature vector may include any feature or characteristic of the sentence (e.g., word count, character count, term frequency, etc.), where the neural network attempts to generate a provided output (or classification) and uses an error from the output (e.g., the difference between the generated output and a known output) to adjust the weight (and bias) values ​​(e.g., via backpropagation or other training techniques). The output layer of the neural network indicates a classification for the input data. Illustratively, output layer neurons may indicate a specific classification (e.g., corresponding to the presence or absence of a feature and / or other information). Furthermore, output layer neurons may be associated with different classes and indicate a probability for the input data to belong to a certain class. The class associated with the highest probability is preferably selected as the classification for the input (e.g., the presence or absence of a feature and / or other information). The description of user intent may be parsed into a sentence that is provided to the machine learning model. The machine learning model may receive sentence text or feature vectors and generate a classification indicating the presence or absence of functionality and / or other information (e.g., quantity of microservices, specified modules or services, etc.) for the corresponding sentence.

[0046] The feature identifier 320 identifies the features indicated in the description of user intent by analyzing sentences classified as containing features by the sentence classifier 310. The feature identifier may be rule-based, where a rule indicates a particular text or text pattern and a corresponding classification. For example, a rule may indicate a particular combination of verbs and nouns to identify a function (e.g., view a portfolio, execute a trade, manage an account, etc.). These patterns may be identified based on annotations provided by the NLP / NLU techniques described above.

[0047] Alternatively, the feature classifier 320 may employ a machine learning model to perform the classification. The feature classifier may use the annotated data and learn over time. Any conventional or other machine learning model (e.g., mathematical / statistical, classifier, feedforward, recurrent, or other neural network, etc.) may be employed. For example, the feature classifier may employ a neural network as described above. The neural network may be trained using sentences (or feature vectors of the sentences) as input and corresponding known classifications (e.g., functions) as output. The feature vectors may include any features or characteristics of the sentences (e.g., word counts, character counts, term frequencies, etc.). The output layer of the neural network indicates a classification for the input data. Illustratively, output layer neurons may indicate specific classifications (e.g., corresponding to functions). Furthermore, output layer neurons may be associated with different classes (or functions) and indicate a probability for the input data to belong to a certain class. The class associated with the highest probability (e.g., based on exceeding or otherwise meeting a threshold) is preferably selected as the classification (e.g., function) for the input. The machine learning model can be trained to identify features (or words) that are used directly as seeds for clustering. Sentences containing the features are provided to the machine learning model. The machine learning model can receive sentence text or feature vectors and generate one or more classifications indicating the features for the corresponding sentences.

[0048] The deduplication module 330 analyzes the identified functions and eliminates duplicates based on synonyms or core domain knowledge. The SEP detector 340 identifies services and service entry points (SEPs) in application code (e.g., how clients, such as calling programs, access the services). The SEP detector may use any conventional or other static analysis tool to identify services exposed through configuration files or annotations in code. Additionally, the SEP detector may analyze runtime logs to detect service entry points (SEPs).

[0049] For example, service entry points (SEPs) can be found in servlet code by searching for the servlet class and identifying the service implementations reachable from the servlet class. For Java API for RESTful Web Services (JAX-RS), service entry points (SEPs) can be found by searching for classes and methods with JAX-RS annotations. For Java Server Faces (JSF), service entry points (SEPs) can be found by extracting the service representation from the display template and discovering the classes and methods that implement the service. For SPRING, service entry points (SEPs) can be found by searching for classes with "Controller" and identifying the service implementations reachable from the class, as well as discovering the REST path as the service entry name. For STRUTS, service entry points (SEPs) can be found by searching a configuration file (e.g., struts-config.xml) and identifying the service implementation and name from the action tag. Service entry points (SEPs) can be discovered for Java API for XML Web Services (JAX-WS) by searching for classes with "WebService" and identifying service implementations reachable from the class.

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

[0051] The mapping may result in a software artifact (e.g., a module or program) of the application that is not mapped to a function. For example, matching or partial matching may not produce a mapping for the software artifact to a function (e.g., based on name, characteristics, etc.); instead, the software artifact may be related or connected to a software artifact that is mapped to the function. In this case, the software artifact is associated with the function by microservice recommender 230 during clustering (e.g., the unmapped software artifact is clustered with the mapped software artifact, etc.). By way of further example, matching or partial matching may not produce a mapping for the software artifact to a function due to attributes (e.g., name, characteristics, etc.) that are significantly different from the function. In this case, the software artifact may indicate or be associated with a new functionality that is absent from the user intent description. This may be determined based on the natural language processing (NLP) and / or natural language understanding (NLU) techniques described above (e.g., annotations and rules for determining functionality based on name or other attributes).

[0052] Mapper 350 may identify missing features related to the user intent description. In other words, there may be additional features in the application code (e.g., modules or programs) that may not have been mapped to features in the user intent description as described above. If features are missing, mapper 350 may present and prompt the user to select the missing features for inclusion in the conversion. The user may also provide a label for the missing features.

[0053] Additionally, 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 user input is requested, mapper 350 may present the mapping of software artifacts to the user's intended functions and allow the user to confirm or modify the mapping (e.g., add or remove software artifacts from the mapping, etc.).

[0054] 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 may be filtered by the mapper 350 based on information in the user intent (e.g., quantity of microservices, specified modules or services, etc.). The software artifacts (e.g., modules or programs) serve as centers or reference points for the corresponding clusters, and the clustering identifies or assigns the remaining modules or programs of the application to clusters based on their proximity to the cluster center. Each cluster corresponds to a microservice with cluster members (or application modules or programs) that exhibit functionality for that 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, confidence, etc.).

[0055] Alternatively, the intent analysis module 224 may employ a machine learning model to receive the description of user intent and determine the mapped software artifact (e.g., module or program). Any conventional or other machine learning model (e.g., mathematical / statistical, classifier, feedforward, recurrent, or other neural network, etc.) may be employed. For example, the intent analysis module may employ a neural network as described above. The neural network may be trained using various descriptions of user intent (or feature vectors of user intent) as input and corresponding known classifications (e.g., corresponding to software artifacts of an application) as output. The feature vectors may include any features or characteristics of the descriptions of user intent (e.g., word count, character count, term frequency, etc.). The output layer of the neural network indicates a classification for the input data. By way of example, output layer neurons may indicate a specific classification (e.g., corresponding to a group of software artifacts, etc.). Furthermore, the output layer neurons may be associated with different classes (or software artifacts) and indicate a probability for the input data to belong to a certain class. The class associated with the highest probability (e.g., exceeding or otherwise meeting a threshold) is preferably selected as the classification (e.g., software artifact) mapped to the input. The description of the user intent may be provided to a machine learning model. The machine learning model may receive the description or feature vector and generate a classification indicative of the software artifact for the corresponding user intent.

[0056] FIG. 4 is a procedural flowchart of a method 400 for transforming an application to a microservices architecture based on user intent, according to one embodiment of the present invention. Initially, various inputs are received by the transformation code 200 at operation 405 to generate microservices for the application. By way of example, the inputs may include the code of the application to be transformed, various documents (e.g., readme or instruction documents, test documents, etc.), and / or a description of user intent for the transformation. The description is preferably in natural language and may include any format (e.g., keywords, text, project descriptions, reference models, business or other languages, etc.) for providing user intent or guidance for performing the transformation. The user intent may include any desired parameters or characteristics for generating resulting microservices (e.g., functions, specific software artifacts, quantities of resulting microservices and / or software artifacts for analysis, parameters, etc.).

[0057] At operation 410, the analysis module 220 identifies features within the description of user intent. The analysis module's intent analysis module 224 parses the description of user intent to determine features within sentences of the description in substantially the same manner as described above. For example, the intent analysis module identifies sentences that contain features and analyzes those sentences to extract the features. This may be accomplished by employing natural language processing (NLP) and / or natural language understanding (NLU), rules, and / or machine learning in substantially the same manner as described above.

[0058] If the intent analysis module 224 does not identify a specific (or any) function within the description of the user intent, as determined in operation 415, then in operation 420 the user is prompted to enter or indicate the function (e.g., prompting the user to specify the function (e.g., as text separated by commas, etc.), highlight text associated with the function from the description, etc.).

[0059] At operation 425, the intent analysis module 224 maps the software artifacts (e.g., modules, 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 converted to provide various information (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 may use information from the program / data analysis module 222 to perform the mapping in substantially the same manner as described above. For example, the mapping may identify one or more software artifacts (e.g., modules or programs) of the application that correspond to the functions using matching or partial matching between the functions and the names or labels of the information identified by the program / data analysis module 222.

[0060] At operation 430, mapper 350 may identify missing features. In other words, there may be additional features in the application code (e.g., modules) that may not have been mapped to features in the user intent description. This may be performed in substantially the same manner as described above. If features are missing, at operation 435, mapper 350 may present and prompt the user to select the missing features to include in the conversion. The user may also provide a label for the missing features.

[0061] In operation 440, mapper 350 identifies one or more software artifacts (e.g., modules or programs) of the application for use as seed modules for clustering by microservice recommender 230. The mapped software artifacts may be provided as seed modules, or the mapped software artifacts may be filtered based on user intent. For example, the user intent may specify a specific module and / or quantity of modules of the application to process. The seed module essentially represents a center or reference point for the corresponding cluster.

[0062] In operation 445, mapper 350 may interact with the user to confirm the mapping of software artifacts (e.g., modules or programs) to the user's intent. If user input is requested, in operation 450, mapper 350 may present the mapping of software artifacts to the user's intent functions and allow the user to confirm or modify the mapping (e.g., add or remove software artifacts from the mapping, etc.).

[0063] In operation 455, microservice recommender 230 performs clustering using the seed modules to determine clusters. The seed modules are used as centers or reference points for the corresponding clusters, and the clustering generates clusters with members (or application modules or programs) that have similar or close functionality to the seed modules. In other words, each cluster corresponds to a microservice whose functionality is represented by the members (or application modules or programs) that belong to that 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, confidence, etc.).

[0064] Clustering may be performed using any conventional or other clustering technique (e.g., K-means clustering, hierarchical clustering, etc.). An unsupervised machine learning model may be employed to perform clustering based on seed software artifacts (e.g., modules or programs), information determined about the application, and a description of user intent. The software artifacts (e.g., modules or programs) of an application are clustered based on features of the application information and the description of user intent. In other words, the clustered software artifacts (e.g., modules or programs) are similar in nature and function. The features may be used to form a feature vector for the corresponding software artifacts (e.g., modules or programs). The feature vector includes one or more vector elements, each containing a value for a corresponding feature. The elements or dimensions of the feature vector define a feature space for clustering. The features may include any desired characteristics or properties of the software artifacts (e.g., type, name, code features, entry point, etc.).

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

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

[0067] The unsupervised machine learning model may be implemented by any conventional or other machine learning model (e.g., a mathematical / statistical model, a classifier, a feedforward, recurrent, or other neural network, 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, where the input layer neurons receive inputs (e.g., feature vectors) and may be associated with weight values. The intermediate and output layer neurons are connected to one or more neurons in the previous layer and receive as inputs the outputs of the connected neurons in the previous layer. Each connection is associated with a weight value, and each neuron generates an output based on a weighted combination of the inputs to that neuron. The output of a neuron may be further based on a bias value for a particular type of neural network (e.g., a recurrent type neural network).

[0068] The weight (and bias) values ​​may be adjusted based on various training techniques. For example, an unsupervised machine learning model may be trained using 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 output) to adjust the weight (and bias) values. The output layer of the neural network indicates a cluster for the input data. By way of example, the output layer neurons may indicate a specific cluster or an identifier for that specific cluster. Furthermore, the output layer neurons may be associated with different clusters and indicate the probability (or confidence) of the input data belonging to the associated cluster. The cluster associated with the highest probability is preferably selected for the input data.

[0069] At operation 460, microservice recommender 230 may interact with a user. If user input is requested, at operation 465, the user may validate the microservice recommendations and / or perform iterative design by moving or rearranging entities (e.g., microservices, functions, members in a cluster, etc.).

[0070] At operation 470, the translation code 200 may generate a code stub 250 (e.g., a code template or skeleton) for the microservice. The code stub preferably includes some implementation code for the microservice (e.g., class or other headers or definitions, variable definitions, library access, etc.) and allows a user to enter code into the body to perform the function. Alternatively, the translation code 200 may automatically generate code for the microservice based on the functionality or code of software artifacts (e.g., modules or programs) belonging to the cluster. At operation 475, the generated microservice may be deployed and executed in a cloud or other distributed computing environment. The microservice represents a transformed version of the application that is suitable for a cloud or other distributed computing environment.

[0071] FIG. 5 is a diagram of an exemplary scenario for converting an application to a microservices architecture based on user intent, according to an embodiment of the present invention. Initially, various inputs may be provided to the conversion code 200 to generate microservices for the application. Illustratively, the inputs may include the code of the application to be converted and a description of user intent 510 for the conversion. The inputs may further include various documents (e.g., a readme or instruction document, test documents, etc.). The description of user intent is preferably in natural language and may include any format (e.g., keywords, text, project descriptions, reference models, business or other languages, etc.) for providing user intent or guidance for performing the conversion. The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functionality, specific software artifacts, quantities of the resulting microservices and / or software artifacts for analysis, parameters, etc.). In other words, the user intent indicates how the user wants to partition or map the application into microservices (e.g., the specific number of microservices to generate, specific modules to consider or exclude, desired functionality, etc.). In this example case, the user intent statement indicates the functions to log in, view portfolio, get stock prices, and transfer stocks.

[0072] The intent analysis module 224 of the analysis module 220 identifies functions within the description of user intent 510 in substantially the same manner as described above. In this case, the intent analysis module parses the description of user intent to determine sentences containing application functions. The intent analysis module 224 identifies at least four functions mentioned in the determined sentences (e.g., authentication (corresponding to “log in”), portfolio management (corresponding to “view portfolio”), stock price lookup (corresponding to “stock prices”), and stock trading (corresponding to “transfer stocks”). The user may be prompted to specify a function (e.g., by specifying a function, highlighting text from the description or other input, etc.) if a specific (or any) function is not identified.

[0073] The program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be converted, as described above, to provide various information (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 to map software artifacts 520 (e.g., modules MOD1-MOD4 as shown in FIG. 5) to the identified functions in a manner substantially similar to that described above. The mapper 350 may identify additional functions in the application other than those indicated in the user intent description. In this case, the user is prompted to select from among the missing functions to include in the conversion in a manner substantially similar to that described above. The mapper 350 may include a software artifact (e.g., MOD5 as shown in FIG. 5) corresponding to the selected function.

[0074] The software artifacts 520 corresponding to the functions (e.g., MOD1-MOD5 as shown in FIG. 5) are provided to the microservice recommender 230 to generate recommended or candidate microservices 530 in substantially the same manner as described above. In this case, the microservice recommender 230 partitions the application into five microservices (corresponding to the five functions) using the application information from the program / data analysis module 222 and the software artifacts 520 (e.g., modules MOD1-MOD5 as shown in FIG. 5) as anchors or centers for the clusters corresponding to the microservices.

[0075] FIG. 6 is a diagram of another example scenario for converting an application to a microservices architecture based on user intent, according to an embodiment of the present invention. Initially, various inputs may be provided to the conversion code 200 to generate microservices for the application. Illustratively, the inputs may include the code of the application to be converted and a description of user intent 610 for the conversion. The inputs may also include various documents (e.g., a readme or instruction document, test documents, etc.). The description is preferably in natural language and may include any format (e.g., keywords, text, project descriptions, reference models, business or other languages, etc.) for providing user intent or guidance for performing the conversion. The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functionality, specific software artifacts, quantities of the resulting microservices and / or software artifacts for analysis, parameters, etc.). In other words, the user intent indicates how the user wants to partition or map the application into microservices (e.g., the specific number of microservices to generate, specific modules to consider or exclude, desired functionality, etc.). In this illustrative case, the user intent description indicates a function (e.g., item capture process), a specific service (e.g., SER1-SER10 as displayed in Figure 6), and the quantity of the specific service to focus on (e.g., the first three of ten offered services).

[0076] The intent analysis module 224 of the analysis module 220 identifies functions and services within the description of the user intent 610 in substantially the same manner as described above. In this case, the intent analysis module parses the description of the user intent to determine the functions within the statement of the user intent and the specific services (e.g., SER1-SER3) to process.

[0077] The program / data analysis module 222 of the analysis module 220, as described above, analyzes the code of the application to be converted and provides various information, including data related to specific modules (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 224 utilizes the application information from the program / data analysis module 222 to map the application's software artifacts 630 to specific services.

[0078] Software artifacts 630 (e.g., modules MOD1-MOD3 as shown in FIG. 6 ) related to a particular service are provided to microservice recommender 230 to generate recommended or candidate microservices in substantially the same manner as described above. In this case, microservice recommender 230 uses application information from program / data analysis module 222 and software artifacts 630 (e.g., modules MOD1-MOD3 as shown in FIG. 6 ) as anchors or centers for clusters corresponding to the microservices to partition the application into three microservices (e.g., corresponding to particular services in the user intent). The microservices may be presented on a user interface. For example, the microservices may 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 relationships or connectivity between the microservices.

[0079] FIG. 7 is a diagram of yet another example scenario for converting an application to a microservices architecture based on user intent, according to an embodiment of the present invention. Initially, various inputs may be provided to the conversion code 200 to generate microservices for the application. Illustratively, the inputs may include the code of the application to be converted and a description of user intent 710 for the conversion. The inputs may also include various documents (e.g., a readme or instruction document, test documents, etc.). The description is preferably in natural language and may include any format (e.g., keywords, text, project descriptions, reference models, business or other languages, etc.) for providing user intent or guidance for performing the conversion. The user intent or guidance may include any desired parameters or characteristics for generating the resulting microservices (e.g., functionality, specific software artifacts, quantities of the resulting microservices and / or software artifacts for analysis, parameters, etc.). In other words, the user intent indicates how the user wants to partition or map the application into microservices (e.g., the specific number of microservices to generate, specific modules to consider or exclude, desired functionality, etc.). In this example case, the user intent description indicates functionality related to solicitation and event handlers.

[0080] The intent analysis module 224 of the analysis module 220 identifies functions within the description of the user intent 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 first two sentences contain information related to functions (e.g., a billing service (e.g., corresponding to "issue a bill") and an event handler service (e.g., corresponding to "event handler"). The user may be prompted to specify a function (e.g., by highlighting text from the description or other input that specifies the function) if a specific (or any) function is not identified.

[0081] As described above, the program / data analysis module 222 of the analysis module 220 analyzes the code of the application to be converted to provide various information (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 to map software artifacts 720 (e.g., modules MOD1-MODN as shown in FIG. 7) to functions in substantially the same manner as described above. In other words, the software artifacts 720 map to event handlers related to claims. The mapper 350 may identify additional functions (e.g., service entry points (SEPs), etc.) in the application beyond those indicated in the user intent description. In this case, the user is prompted to select from among the missing features to include in the conversion in substantially the same manner as described above, and mapper 350 may include software artifacts corresponding to the selected features.

[0082] The software artifacts 720 corresponding to the functions (e.g., MOD1 through MOD N as displayed in FIG. 7) are provided to microservice recommender 230 to generate recommended or candidate microservices 730 in substantially the same manner as described above. In this case, microservice recommender 230 partitions the application into various microservices using application information from program / data analysis module 222 and the software artifacts 720 as anchors or centers for the clusters corresponding to the microservices.

[0083] Embodiments of the present invention provide various technical and other advantages. For example, embodiments of the present invention convert applications for a centralized architecture into a format for deployment and execution in a distributed architecture with reduced iterations, thereby saving computing processing and resources. Furthermore, code may be automatically generated for microservices to reduce errors, thereby saving computing processing and resources (e.g., reduced compile time / trials, fewer runtime errors, etc.).

[0084] Furthermore, the machine learning model may learn complex combinations of mappings and clustering, which increases accuracy and reduces unnecessary processing of erroneous features, which reduces consumption of processing and memory / storage resources and improves computing performance.

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

[0086] Additionally, a 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 a machine learning model to increase the confidence in the software artifact for the new function (e.g., to update or train a machine learning model to increase the probability of the software artifact for the new function).

[0087] Furthermore, the software artifact may be assigned to a cluster with a lower confidence or probability. The 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 for the software artifact for the new cluster (e.g., to update or train a machine learning model to increase the probability of the software artifact for the new cluster, etc.).

[0088] Therefore, the machine learning model may be continuously evolved (or trained) to learn more functions, mappings, and / or clusterings as microservices are generated.

[0089] It will be understood that the embodiments described above and illustrated in the figures represent only some of the many ways to implement embodiments for transforming an application to a microservices architecture.

[0090] The environment for 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, where embodiments of the present invention may be applied to any desired type of computing environment (e.g., cloud computing, client / server, network computing, mainframe, standalone systems, etc.). Computers or other processing systems employed by embodiments of the present invention may be implemented by any number of any personal or other type of computer or processing system. These systems may include any type of monitor and input device (e.g., keyboard, mouse, voice recognition, etc.) for entering and / or displaying information.

[0091] It is understood that the software of embodiments of the present invention (e.g., production code 200, parsing module 220, intent analysis module 224, microservice recommender 230, sentence classifier 310, feature identifier 320, deduplication module 330, SEP detector 340, mapper 350, etc.) may be implemented in any desired computer language and developed by one of ordinary skill in the computer arts based on the functional descriptions contained herein and the flowcharts shown in the figures. Furthermore, any references herein to software performing various functions generally refer to a computer system or processor that performs those functions under software control. The computer system of embodiments of the present invention may alternatively be implemented by any type of hardware and / or other processing circuitry.

[0092] 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, where the computers or processing systems may be located locally or remotely from one another and may communicate via any suitable communications medium (e.g., LAN, WAN, intranet, Internet, hardwire, modem connection, wireless, etc.). For example, the functions of embodiments of the present invention may be distributed in any manner among various end-user / client and server systems and / or any other intervening processing devices. The software and / or algorithms described above and illustrated in the flowcharts may be modified in any manner that achieves the functions described herein. Additionally, the functions in the flowcharts or illustrations may be performed in any order that achieves the desired operations.

[0093] The communications network may be implemented by any number of any type of communications network (e.g., LAN, WAN, Internet, intranet, VPN, etc.). The computer or other processing system of embodiments of the present invention may include any conventional or other communications device for communicating over the network via any conventional or other protocol. The computer or other processing system may utilize any type of connection (e.g., wired, wireless, etc.) to access the network. The local communications medium may be implemented by any suitable communications medium (e.g., local area network (LAN), hardwire, wireless link, intranet, etc.).

[0094] 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.) for storing 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.) for storing information. The database system may be contained within or coupled to server and / or client systems. 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.

[0095] Embodiments of the present invention may employ any number of any type of user interface (e.g., graphical user interface (GUI), command line, prompt, etc.) for obtaining or providing information (e.g., functions, mappings, clustering, etc.), where an interface may include any information arranged in any manner. An 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 enter / display information via any suitable input device (e.g., mouse, keyboard, etc.) and initiate desired actions. Interface screens may include any suitable actuators (e.g., links, tabs, etc.) for navigating between screens in any manner.

[0096] Reports may contain any information arranged in any manner and may be configurable based on rules or other criteria to provide desired information to users (e.g., microservices, software artifacts, etc.).

[0097] Embodiments of the present invention are not limited to the specific tasks or algorithms described above, but may be utilized to translate or convert any application to any distributed computing environment.

[0098] An application may be of any type for conversion to a distributed computing environment (e.g., a monolith application, etc.). For example, embodiments of the present invention may be used to restructure or optimize a distributed application into different microservices. The conversion may be for any distributed computing environment (e.g., cloud, etc.). An application may be partitioned into any number of any software or other components of a distributed computing environment. Furthermore, a microservice may be any software module or other component of a distributed computing environment that performs any part of an overall process (e.g., any service or service portion, any part or operation of an overall process to be performed, etc.). Software artifacts may include any items related to the software or code of an application (e.g., modules or programs of source and / or compiled code, documentation, data structures, data, test cases, transactions, endpoints, service entry points (SEPs), etc.). A module may include any part of application code (e.g., program, method, routine, function, data structure, data, etc.).

[0099] The user intent may include any format (e.g., keywords, text, project description, reference model, business or other language, readme or application description document, etc.) for providing user intent or guidance for performing the transformation.

[0100] The program / data analysis module may obtain any information related to application code (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.).

[0101] 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., identifying entities), relationship extraction (e.g., identifying relationships between entities, such as parent / child, contains, is a, etc.), semantic analysis (e.g., term meanings, 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, feedforward, recurrent, or other neural network, etc.) to extract information and / or perform the mapping. The mapping may utilize any type of matching or mapping (e.g., partial matching, probabilistic matching, machine learning, etc.) to map any quantity of software artifacts to any quantity of features. Furthermore, machine learning models may be trained to identify features in user intent (e.g., words, module or program names, etc.), which may be directly used as seeds for clustering. These features can be used alone or in combination with the mapped software artifacts as seeds for clustering.

[0102] The microservice recommender may utilize any conventional or other clustering technique (e.g., K-means clustering, hierarchical clustering, etc.) and may use any type of software artifact or function as a center or reference point for the clusters. The clustering may produce any number of clusters with any number of members or software artifacts. Software artifacts assigned to different clusters may be resolved in any manner (e.g., by highest probability or confidence, etc.). The microservice recommender may utilize any conventional or other machine learning model (e.g., mathematical / statistical model, classifier, feedforward, recurrent, or other neural network, etc.).

[0103] Code for a microservice can be generated in any manner. For example, a code stub can be generated for a user to provide code for a function. Alternatively, the code (including the function) can be automatically generated in any manner. For example, the code can be generated based on the function or code of a software artifact (e.g., a module or program) that belongs to the cluster (e.g., code reuse, generation of new or equivalent code, etc.).

[0104] Microservices may be deployed to any number or combination of processing devices in any cloud or other distributed computing environment and may execute in any manner (e.g., serially, in parallel, etc.). Converting an application to distributed microservices allows for faster processing times and conserves resources because multiple processing devices are performing functions (e.g., at least some of the processing is performed in parallel, etc.). Microservices may be deployed to distributed computing environments to execute based on resource availability to provide improved processing times for application functions.

[0105] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises," "comprising," "includes," "including," "has," "have," "having," "with," and the like, when used herein, specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0106] In the following claims, the corresponding structure, material, acts, and equivalents of all means or step-plus-function elements are intended to include any structure, material, or acts for performing the function in combination with other claimed elements as specifically claimed. The description of various embodiments of the present invention has been presented for illustrative purposes but is not intended to be exhaustive or limited to the disclosed embodiments. Numerous modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terminology used herein has been selected to best explain the principles, practical applications, or technical improvements over commercially available technologies of the embodiments, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A method of converting an application for a distributed computing environment, comprising: analyzing, via at least one processor, a 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 functions, wherein the plurality of software artifacts form different groups of software artifacts; via the at least one processor, assigning remaining software artifacts of the application to the different groups based on remaining software artifacts corresponding to the mapped software artifacts of the groups, wherein the different groups correspond to microservices for the distributed computing environment; Presenting the microservices for the distributed computing environment based on the different groups via the at least one processor. A method comprising:

2. The method of claim 1 , wherein the application comprises a monolith application and the plurality of software artifacts comprises modules of the monolith application.

3. The stage of allocating the remaining software artifacts comprises: clustering the remaining software artifacts of the application by a machine learning model based on the mapped software artifacts that serve as reference points for clusters, where the clusters correspond to the different groups; 2. The method of claim 1, comprising:

4. Mapping a plurality of software artifacts of the application includes: determining that the application has additional functionality related to the description of the user intent; receiving a user selection of one or more of the additional features to transform the application; 2. The method of claim 1, comprising:

5. generating, via the at least one processor, the microservices for the distributed computing environment based on functionality of the software artifacts in corresponding groups. The method of claim 1 further comprising:

6. The description of user intent includes a natural language, and analyzing the description of user intent includes: analyzing the description of user intent using natural language processing techniques and machine learning models to extract the information for transforming the application; 2. The method of claim 1, comprising:

7. 10. The method of claim 1, wherein the extracted information further indicates a quantity of microservices, and the quantities of the different groups correspond to the quantities of the microservices.

8. 1. A system for converting an application for a distributed computing environment, comprising: one or more memories; at least one processor coupled to the one or more memories, wherein the at least one processor: analyzing a 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 functions, wherein the plurality of software artifacts form different groups of software artifacts; assigning remaining software artifacts of the application to the different groups based on remaining software artifacts corresponding to the mapped software artifacts of the groups, where the different groups correspond to microservices for the distributed computing environment; Presenting the microservices for the distributed computing environment based on the different groups. configured to: A system comprising:

9. Allocating the remaining software artifacts is clustering the remaining software artifacts of the application by a machine learning model based on the mapped software artifacts that serve as reference points for clusters, where the clusters correspond to the different groups; The system of claim 8 , comprising:

10. Mapping a plurality of software artifacts of the application includes: determining that the application has additional functionality related to describing the user intent; receiving a user selection of one or more of the additional features to transform the application; The system of claim 8 , comprising:

11. The at least one processor generating the microservices for the distributed computing environment based on the functionality of the software artifacts in the corresponding groups; The system of claim 8 , further configured to:

12. The description of user intent includes natural language, and analyzing the description of user intent includes: analyzing the description of user intent with natural language processing techniques and machine learning models to extract the information for transforming the application; The system of claim 8 , comprising:

13. 10. The system of claim 8, wherein the extracted information further indicates a quantity of microservices, and wherein the quantities of the different groups correspond to the quantities of the microservices.

14. 1. A computer program product for converting an application for a distributed computing environment, the computer program product comprising one or more computer-readable storage media having program instructions, the program instructions collectively stored on the one or more computer-readable storage media, the program instructions causing at least one processor to: analyzing a description of user intent to extract information for transforming said application, wherein said extracted information indicates functionality for said distributed computing environment; mapping a plurality of software artifacts of the application to the functions, wherein the plurality of software artifacts form different groups of software artifacts; assigning remaining software artifacts of the application to the different groups based on remaining software artifacts corresponding to the mapped software artifacts of the groups, where the different groups correspond to microservices for the distributed computing environment; presenting the microservices for the distributed computing environment based on the different groups. a computer program product executable by the at least one processor to cause the

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

16. The steps to assign the remaining software artifacts are: clustering the remaining software artifacts of the application by a machine learning model based on the mapped software artifacts that serve as reference points for clusters, where the clusters correspond to the different groups; 15. The computer program product of claim 14, comprising:

17. The step of mapping a plurality of software artifacts of the application comprises: determining that the application has additional functionality related to the description of the user intent; receiving a user selection of one or more of the additional features to transform the application; 15. The computer program product of claim 14, comprising:

18. The program instructions cause the at least one processor to: generating the microservices for the distributed computing environment based on functionality of the software artifacts in corresponding groups; 15. The computer program product of claim 14, further comprising:

19. The description of user intent includes natural language, and the step of analyzing the description of user intent includes: analyzing the description of user intent using natural language processing techniques and machine learning models to extract the information for transforming the application; 15. The computer program product of claim 14, comprising:

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

Images