Computer-implemented method, computer system, and computer program (predicting work effort for porting software projects across disparate platforms)

Abstract

To enable accurate determination of the work effort required to port large-scale software projects across disparate platforms.SOLUTION: A method of predicting porting work effort is provided. A total porting work effort to port a software project from a source platform to a disparate target platform is predicted using a first porting work effort, a second porting work effort, and a third porting work effort. The software project is ported from the source platform to the disparate target platform provided that the total porting work effort is less than a defined maximum porting work effort threshold level.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present disclosure relates generally to software projects, and more particularly to porting software projects. [Background technology]

[0002] A software project is the complete procedure of software development, from requirements gathering to testing and maintenance. Porting is the process of adapting a software project for the purpose of achieving some form of execution on a platform (e.g., a different operating system, third-party libraries, processor, and the like) (e.g., computing environment) different from the platform for which the software project was originally designed. A software project is portable if the effort required to port it to a new platform is less than the effort required to build the software project from scratch. Summary of the Invention [Problem to be solved by the invention]

[0003] It is impossible to accurately determine the amount of effort required to port a large software project across different platforms. [Means for solving the problem]

[0004] According to one exemplary embodiment, a computer-implemented method for predicting porting effort is provided. The computer utilizes a sixth machine learning model to predict a total porting effort for porting a software project from a source platform to a heterogeneous target platform using a first porting effort, a second porting effort, and a third porting effort. The computer ports the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level. According to other exemplary embodiments, a computer system and a computer program product for predicting porting effort are provided. [Brief explanation of the drawings]

[0005] [Figure 1] 1 is a pictorial representation of a computing environment in which an exemplary embodiment may be implemented.

[0006] [Figure 2] FIG. 1 illustrates an example of a porting effort prediction system, according to an exemplary embodiment.

[0007] [Figure 3] FIG. 1 illustrates an example of a machine learning training process, according to an exemplary embodiment.

[0008] [Figure 4] FIG. 1 illustrates an example of a porting effort forecasting process, according to an illustrative embodiment.

[0009] [Figure 5] FIG. 10 illustrates an example of a porting effort forecast table according to an exemplary embodiment.

[0010] [Figure 6] FIG. 1 illustrates an example of a base porting effort forecasting process, according to an illustrative embodiment.

[0011] [Figure 7] FIG. 1 illustrates an example of a process for predicting the number of new test cases, according to an illustrative embodiment.

[0012] [Figure 8] FIG. 1 illustrates an example of a bug count prediction process, according to an illustrative embodiment.

[0013] [Figure 9] FIG. 1 illustrates an example of a total porting effort forecasting process, according to an illustrative embodiment.

[0014] [Figure 10A] 1 is a flowchart illustrating a process for estimating porting effort in accordance with an illustrative embodiment. [Figure 10B] 1 is a flowchart illustrating a process for estimating porting effort in accordance with an illustrative embodiment. [Figure 10C] 1 is a flowchart illustrating a process for estimating porting effort in accordance with an illustrative embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0015] A computer-implemented method provides for predicting porting effort. The computer utilizes a sixth machine learning model to predict a total porting effort for porting a software project from a source platform to a heterogeneous target platform using a first porting effort, a second porting effort, and a third porting effort. The computer ports the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level. As a result, the exemplary embodiment provides the technical effect of accurately predicting the total effort required to port a software project from a source platform to a heterogeneous target platform based on three different porting effort estimates using multiple machine learning models.

[0016] The computer also utilizes a first machine learning model to predict the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase. As a result, exemplary embodiments provide the technical effect of using a first machine learning model to predict a first porting effort based on feature data corresponding to multiple different phases associated with a software project porting process.

[0017] Additionally, the computer utilizes a second machine learning model to predict a number of new test cases using feature data corresponding to a test phase, including a configuration phase, a compilation phase, a linking phase, a code modification phase, and the number of original test cases used during construction of the software project. The computer utilizes a third machine learning model to predict the second porting effort using the predicted number of new test cases included in the feature data corresponding to the test phase. As a result, the exemplary embodiments provide the technical effect of using a second machine learning model to predict a number of new test cases required based on feature data corresponding to multiple different phases associated with a software project porting process, including a test phase indicating the number of original test cases used during construction of a particular software project, and using a third machine learning model to predict the second porting effort based on the predicted number of new test cases.

[0018]

[0014] Furthermore, the computer utilizes a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase. The computer utilizes a fifth machine learning model to predict the third porting effort using the predicted number of detected bugs included in the feature data corresponding to a bug fix phase. As a result, the exemplary embodiments provide the technical effect of using a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases based on feature data corresponding to multiple different phases associated with a software project porting process, and using a fifth machine learning model to predict the third porting effort based on the predicted number of detected bugs.

[0019] Furthermore, the first porting effort is a base porting effort, the second porting effort is a testing effort, and the third porting effort is a bug fixing effort. As a result, the exemplary embodiments provide a technical effect of identifying three different porting efforts, including a base porting effort, a testing effort, and a bug fixing effort, to accurately predict the total effort required to port a software project from a source platform to a heterogeneous target platform, and detecting and fixing bugs that may cause vulnerabilities, thereby improving software project security during the porting process between heterogeneous platforms.

[0020] Further, the computer receives a request to port the software project from the source platform to the heterogeneous target platform. In response to the request, the computer retrieves a set of historical data corresponding to a similar software project previously ported to a similar target platform. The computer performs an analysis of the set of historical data corresponding to the similar software project previously ported to the similar target platform. The computer extracts, based on the analysis of the set of historical data corresponding to the similar software project previously ported to the similar target platform, feature data for each of a plurality of phases associated with a software project porting process from the set of historical data. The plurality of phases includes a configuration phase, a compilation phase, a linking phase, a code modification phase, a testing phase, and a bug fixing phase. As a result, the illustrative embodiments provide the technical effect of extracting, based on the analysis of the set of historical data, feature data for each of a plurality of phases associated with a software project porting process, including a configuration phase, a compilation phase, a linking phase, a code modification phase, a testing phase, and a bug fixing phase, from the set of historical data corresponding to a similar software project previously ported to a similar target platform.

[0021] The computer trains a first machine learning model to predict the first porting effort using the feature data corresponding to the configure phase, the compile phase, the link phase, and the code modification phase. As a result, exemplary embodiments provide the technical effect of training a first machine learning model to predict a first porting effort using feature data corresponding to multiple different phases associated with a software project porting process.

[0022] The computer also trains a second machine learning model to predict a number of new test cases using the feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the test phase, which includes the number of original test cases used during construction of the software project. The computer trains a third machine learning model to predict the second porting effort using the number of new test cases included in the feature data corresponding to the test phase. As a result, the exemplary embodiments provide the technical effect of training a second machine learning model to predict a number of new test cases using feature data corresponding to multiple different phases associated with a software project porting process, including a test phase indicating the number of original test cases used during construction of a particular software project, and training a third machine learning model to predict the second porting effort using the number of new test cases.

[0023] Additionally, the computer trains a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases using the feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the testing phase. The computer trains a fifth machine learning model to predict the third porting effort using the number of detected bugs included in the feature data corresponding to the bug fix phase. As a result, the exemplary embodiments provide the technical effect of training a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the testing phase associated with a software project porting process, and training a fifth machine learning model to predict the third porting effort using the number of detected bugs.

[0024] Furthermore, the computer trains the sixth machine learning model to predict the total porting effort using the first porting effort, the second porting effort, and the third porting effort. As a result, the exemplary embodiment provides a technical effect of training a sixth machine learning model to accurately predict the total porting effort using three different porting efforts.

[0025] A computer system for predicting porting effort includes a communications fabric, a set of computer-readable storage media connected to the communications fabric, where the set of computer-readable storage media collectively store program instructions, and a set of processors connected to the communications fabric, where the set of processors execute the program instructions. The computer system utilizes a sixth machine learning model to predict a total porting effort for porting a software project from a source platform to a heterogeneous target platform using a first porting effort, a second porting effort, and a third porting effort. The computer system ports the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level. As a result, the illustrative embodiment provides the technical effect of accurately predicting the total effort required to port a software project from a source platform to a heterogeneous target platform based on three different porting effort levels using multiple machine learning models.

[0026] The computer system also utilizes a first machine learning model to predict the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase. As a result, exemplary embodiments provide the technical effect of using a first machine learning model to predict a first porting effort based on feature data corresponding to multiple different phases associated with a software project porting process.

[0027] Additionally, the computer system utilizes a second machine learning model to predict a number of new test cases using feature data corresponding to a test phase, including a configuration phase, a compilation phase, a linking phase, a code modification phase, and the number of original test cases used during construction of the software project. The computer system utilizes a third machine learning model to predict the second porting effort using the predicted number of new test cases included in the feature data corresponding to the test phase. As a result, the exemplary embodiments provide the technical effect of using a second machine learning model to predict a number of new test cases required based on feature data corresponding to multiple different phases associated with a software project porting process, including a test phase indicating the number of original test cases used during construction of a particular software project, and using a third machine learning model to predict the second porting effort based on the predicted number of new test cases.

[0028] Additionally, the computer system utilizes a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase. The computer system utilizes a fifth machine learning model to predict the third porting effort using the predicted number of detected bugs included in the feature data corresponding to a bug fix phase. As a result, the exemplary embodiments provide the technical effect of using a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases based on feature data corresponding to multiple different phases associated with a software project porting process, and using a fifth machine learning model to predict the third porting effort based on the predicted number of detected bugs.

[0029] Furthermore, the first porting effort is a base porting effort, the second porting effort is a testing effort, and the third porting effort is a bug fixing effort. As a result, the exemplary embodiments provide a technical effect of identifying three different porting efforts, including a base porting effort, a testing effort, and a bug fixing effort, to accurately predict the total effort required to port a software project from a source platform to a heterogeneous target platform, and detecting and fixing bugs that may cause vulnerabilities, thereby improving software project security during the porting process between heterogeneous platforms.

[0030] A computer program product for predicting porting effort comprises a set of computer-readable storage media having program instructions collectively stored thereon, the program instructions being executable by a computer. The computer utilizes a sixth machine learning model to predict a total porting effort for porting a software project from a source platform to a heterogeneous target platform using a first porting effort, a second porting effort, and a third porting effort. The computer ports the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level. As a result, exemplary embodiments provide the technical effect of accurately predicting the total effort required to port a software project from a source platform to a heterogeneous target platform based on three different porting effort estimates using multiple machine learning models.

[0031] The computer also utilizes a first machine learning model to predict the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase. As a result, exemplary embodiments provide the technical effect of using a first machine learning model to predict a first porting effort based on feature data corresponding to multiple different phases associated with a software project porting process.

[0032] Additionally, the computer utilizes a second machine learning model to predict a number of new test cases using feature data corresponding to test phases, including a configuration phase, a compilation phase, a linking phase, a code modification phase, and the number of original test cases used during construction of the software project. The computer utilizes a third machine learning model to predict the second porting effort using the predicted number of new test cases included in the feature data corresponding to the test phases. As a result, the exemplary embodiments provide the technical effect of using a second machine learning model to predict the number of new test cases required based on feature data corresponding to multiple different phases associated with a software project porting process, including a test phase indicating the number of original test cases used during construction of the particular software project, and using a third machine learning model to predict the second porting effort based on the predicted number of new test cases.

[0033]

[0014] Furthermore, the computer utilizes a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase. The computer utilizes a fifth machine learning model to predict the third porting effort using the predicted number of detected bugs included in the feature data corresponding to a bug fix phase. As a result, the exemplary embodiments provide the technical effect of using a fourth machine learning model to predict the number of bugs detected during execution of the original number of test cases and the predicted number of new test cases based on feature data corresponding to multiple different phases associated with a software project porting process, and using a fifth machine learning model to predict the third porting effort based on the predicted number of detected bugs.

[0034] Furthermore, the first porting effort is a base porting effort, the second porting effort is a testing effort, and the third porting effort is a bug fixing effort. As a result, the exemplary embodiments provide a technical effect of identifying three different porting efforts, including a base porting effort, a testing effort, and a bug fixing effort, to accurately predict the total effort required to port a software project from a source platform to a heterogeneous target platform, and detecting and fixing bugs that may cause vulnerabilities, thereby improving software project security during the porting process between heterogeneous platforms.

[0035] Various aspects of the present disclosure are illustrated by 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, depending also 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.

[0036] 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 contained in 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. Without limitation, the 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 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 transitory signals 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 transmitted 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 this does not make the storage device temporary because the data is not temporary while it is stored.

[0037] Referring now to the figures, and in particular to Figures 1-2, diagrams of data processing environments are provided in which illustrative embodiments may be implemented. It should be understood that Figures 1-2 are intended as examples only and are not intended to assert or imply any limitation with regard to the environments in which different embodiments may be implemented. Many modifications to the depicted environments may be made.

[0038] FIG. 1 illustrates a diagrammatic representation of a computing environment in which an exemplary embodiment may be implemented. The computing environment 100 includes an example environment for the execution of at least a portion of computer code involved in performing the inventive methodology of the exemplary embodiment, such as porting effort prediction code 200. For example, the porting effort prediction code 200 utilizes multiple trained machine learning models to predict the total amount of effort required to port a software project from a source platform to a heterogeneous target platform. The porting effort prediction code 200 extracts features or metrics for each of multiple phases associated with porting a software project from historical data corresponding to previously ported software projects. The multiple phases may include, for example, a configuration phase, a compilation phase, a linkage phase, a code modification phase, a testing phase, a bug fixing phase, and the like.

[0039] The porting effort prediction code 200 determines multiple prediction functions using different machine learning models for different phases of the software project porting process. The porting effort prediction code 200 uses a first prediction function of a first machine learning model to predict the base porting effort (E1) using feature data corresponding to the configuration, compilation, linking, and code modification phases. The porting effort prediction code 200 uses a second prediction function of a second machine learning model to predict the number of required new test cases using feature data corresponding to the configuration, compilation, linking, and code modification phases and the number of original test cases used during the initial construction of the software project. The porting effort prediction code 200 uses a third prediction function of a third machine learning model to predict the testing effort (E2) using the number of original test cases used and the predicted number of required new test cases.

[0040] The porting effort prediction code 200 utilizes a fourth prediction function of a fourth machine learning model to predict the number of bugs detected during test case execution using feature data corresponding to the configuration, compilation, linkage, and code modification phases, as well as the number of original test cases used and the predicted number of new test cases required. The porting effort prediction code 200 utilizes a fifth prediction function of a fifth machine learning model to predict the bug fixing effort (E3) using the predicted number of detected bugs. The porting effort prediction code 200 utilizes a sixth prediction function of a sixth machine learning model to predict the total porting effort (ET) for porting a software project across heterogeneous platforms using the base porting effort (E1), the testing effort (E2), and the bug fixing effort (E3).

[0041] As a result, the porting effort prediction code 200 can use multiple machine learning models to accurately predict the total effort required to port a software project from a source platform to a heterogeneous target platform. In addition, the porting effort prediction code 200 can improve software project security during the porting process between heterogeneous platforms by detecting and fixing bugs that may cause vulnerabilities.

[0042] 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 addition to porting effort prediction code 200. 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 porting effort prediction code 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.

[0043] Computer 101 may take the form of a mainframe computer, a quantum computer, a desktop computer, a laptop computer, a tablet computer, or any other type of computer now known or later developed that is capable of, for example, executing programs, accessing networks, and querying databases, such as remote database 130. As is well understood in the field of computer technology, and depending on the technology, performance of a computer-implemented method may be distributed among multiple computers and / or multiple locations. However, 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 FIG. 1 within a cloud, it may be located within a cloud. However, computer 101 is not required to reside within a cloud except to any extent that may be expressly indicated.

[0044] Processor set 110 includes one or more computer processors of any type now known or to be developed in the future. Processing circuitry 120 may be distributed across multiple packages, e.g., multiple tailored 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.

[0045] Computer-readable program instructions are typically loaded onto computer 101 and cause processor set 110 of computer 101 to execute a series of operational steps, thereby enabling a computer-implemented methodology, such that the executed instructions instantiate the methods specified in the computer-implemented method flowcharts and / or descriptions contained herein (collectively referred to as the "invention methods"). 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 inventive methods. In computing environment 100, at least a portion of the instructions for executing the inventive methods of an exemplary embodiment may be stored in porting effort prediction code 200 in persistent storage 113.

[0046] 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.

[0047] Volatile memory 112 may be any type of volatile memory now known or later developed. Examples include dynamic random access memory (RAM) or static 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.

[0048] 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 regardless of whether power is supplied to computer 101 and / or to persistent storage 113 directly. Persistent storage 113 can 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 can take several forms, including various known proprietary operating systems or open-source Portable Operating System Interface-type operating systems that employ a kernel.

[0049] 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 can 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 through a local area communication network, and even connections made through a wide area network such as the Internet. In various embodiments, the UI device set 123 can include components such as a display screen, speakers, microphones, wearable devices (such as smart glasses and smart watches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. The storage 124 can be external storage, such as an external hard drive, or insertable storage, such as an SD card. The storage 124 can be persistent and / or volatile. In some embodiments, 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), then 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 is made up of sensors that may be used in Internet of Things applications. For example, one sensor may be a thermometer and another sensor may be a motion detector.

[0050] 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 multiple different network hardware devices. Computer-readable program instructions for implementing the methods of the present invention may 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.

[0051] WAN 102 is any wide area network (e.g., the Internet) capable of communicating computer data over non-local distances by any technology for communicating computer data now known or later developed. 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.

[0052] EUD 103 is any computer system used and controlled by an end user (e.g., a program developer utilizing a software project porting effort forecasting service provided by computer 101) and may take any of the forms described above with respect to computer 101. EUD 103 typically receives useful and useful data from the operation of computer 101. For example, in a hypothetical case in which computer 101 is designed to provide a software project porting effort forecast to an end user, this recommendation would typically be communicated from computer 101's network module 115 over WAN 102 to EUD 103. In this manner, EUD 103 can display or otherwise present the software project porting effort forecast 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, a laptop computer, a tablet computer, a smartphone, a smartwatch, and the like.

[0053] 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 software project porting effort forecasts based on historical data, then this historical data may be provided to computer 101 from remote database 130 of remote server 104.

[0054] 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 capabilities, 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 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 running on various computers comprising host physical machine set 142, which is the universe of physical computers within 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 can be stored as images and can be transferred among and between various physical machine hosts, either as images or after instantiation of the VCEs. 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.

[0055] Some further description of virtualized computing environments (VCEs) is now provided. A VCE can be stored as an "image." A new, active instance of a VCE can be instantiated from an image. Two well-known types of VCEs are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to a feature of an operating system in which the kernel allows 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 within them. A computer program running on a typical 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.

[0056] A private cloud 106 is similar to a public cloud 105, except that computing resources are available for use only by a single entity. While the private cloud 106 is shown in communication 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.

[0057] Public cloud 105 and private cloud 106 are programmed and configured to provide cloud computing services and / or microservices (not separately shown in FIG. 1 ). Unless otherwise indicated, the term “microservices” should be interpreted to include larger “services” regardless of scale. A cloud service is typically an infrastructure, platform, or software hosted by a third-party provider and made available to users over the Internet. A cloud service facilitates the flow of user data from front-end clients (e.g., user-side servers, tablets, desktops, or laptops) over the Internet to the provider's systems and vice versa. In some embodiments, cloud services can be configured and orchestrated according to the “as a service” technology paradigm, where something is presented to internal or external customers in the form of a cloud computing service. An as-a-service offering typically provides endpoints with which various customers interface. These endpoints are typically based on a set of application programming interfaces (APIs). One category of as-a-service offerings is Platform as a Service (PaaS), where a service provider provisions, instantiates, runs, and manages modular bundles of code that customers can use to instantiate a computing platform and one or more applications without the complexities of building and maintaining the infrastructure typically associated with these. Another category is Software as a Service (SaaS), where software is centrally hosted and allocated on a subscription basis. SaaS is also known as on-demand software, web-based software, or web-hosted software.The four technology subfields involved in cloud services are deployment, integration, on-demand, and virtual private networks.

[0058] As used herein, when used in reference to items, a "set of" means one or more of the items. For example, a set of clouds is one or more different types of cloud environments. Similarly, when used in reference to items, a "number of" means one or more of the items. Furthermore, a "group of" or "plurality of" when used in reference to items means two or more of the items.

[0059] Furthermore, the term "at least one of," when used in conjunction with a list of items, means that one or more different combinations of the listed items may be used, and only one of each item in the list may be required. In other words, "at least one of" means that any combination of items and numbers of items from the list may be used, but not all items in the list are required. An item may be a specific object, thing, or category.

[0060] For example, without limitation, "at least one of item A, item B, or item C" may include item A, item A and item B, or item B. This example may also include item A, item B, and item C, or item B and item C. Of course, any combination of these items may be present. In some illustrative examples, "at least one of" may be, for example, without limitation, two of item A; one of item B; and ten of item C; four of item B and seven of item C; or other suitable combinations.

[0061] To support cloud development, open source software is increasingly emerging across many different types of platforms, especially with regard to supporting containers. Porting open source software across platforms is one way to build a robust ecosystem. When porting a new software project to a different type of platform, it can be difficult to determine the amount of porting effort required due to the differences between the two disparate or heterogeneous platforms.

[0062] As a result, it is difficult for software development teams to accurately determine the appropriate porting effort. Although the effort used to originally develop a software project can be used as a starting point, the effort used to originally develop a software project is only partially accurate because the software porting process differs from the software development process due to the increased complexity associated with porting a software project across heterogeneous platforms.

[0063] Currently, solutions exist that can evaluate and determine software project development costs. However, these current solutions for determining software project development costs cannot accurately determine the effort required to port a large software project across heterogeneous platforms because these current solutions do not consider factors such as, for example, the different phases associated with porting a software project, which significantly affect the effort corresponding to porting a software project across heterogeneous platforms. The different phases associated with porting a software project may include, for example, configuration, compilation, linking, code modification, testing, bug fixing, and the like. The illustrative embodiments use multiple trained machine learning models to accurately predict the amount of effort required to port a software project across heterogeneous platforms based on feature data or metrics corresponding to the different phases associated with porting a software project.

[0064] For example, the illustrative embodiments retrieve historical porting effort data corresponding to a number (e.g., less than 100) of previously ported software projects, extract features (e.g., metrics) for each of the plurality of distinct phases from the retrieved historical porting effort data associated with the number of previously ported software projects, and utilize curve fitting and machine learning models to determine an amount of effort that each of the plurality of distinct phases contributes to the total amount of effort required to port the software project from one type of platform to a different, disparate type of platform. The illustrative embodiments then utilize the amount of effort that each of the plurality of phases contributes to porting the software project from one type of platform to a different type of platform to predict the total amount of effort required to port the software project between the disparate platform types.

[0065] The porting effort for a software project is based in part on the type of programming language and the type of target platform. As a result, the data used in training the machine learning models must correspond to the same type of programming language being ported to the same type of target platform. For example, the porting effort required to port a C programming language project to a mainframe operating system platform is quite different from porting a GO programming language project to an open source operating system platform. While a large amount of historical data associated with porting software projects in the same programming language to the same target platform may not be readily available, the illustrative embodiments can train multiple machine learning models using only a small amount of historical data related to porting software projects.

[0066] As used herein, the term "phase" refers to a specific stage in porting a software project and the data used in that specific phase. Such phases may include, for example, configuration, compilation, linking, code modification, testing, bug fixes, and the like. The configuration phase includes, for example, executing code to identify the target environment (e.g., platform, operating system, hardware, software, and the like), tools (e.g., compiler, linker, and the like), dependencies (e.g., software dependencies, library dependencies, other software package dependencies, and the like), and options (e.g., runtime options, compiler options, linker options, and the like), and generating commands (e.g., compile commands, linkage commands, and the like). The compilation phase includes, for example, executing compile commands so that a compiler converts the source code of the software project into machine-level instructions. The linking phase includes, for example, executing linkage commands so that a linker locates symbols in different objects and libraries and thus generates an executable program. The code modification phase includes, for example, modifying source code in one or more phases so that the source code can be executed on the target platform. The testing phase includes, for example, verifying program functionality by running test cases before or while the software project is ported to the target platform. Note that exemplary embodiments may generate new test cases during porting of the software project to the target platform. The bug fixing phase includes, for example, locating and identifying the cause of a failure in a test case, and then fixing the cause of the failure in the test case (e.g., fixing the software bug with a software patch or update).If the illustrative embodiments need to evaluate one or more other phases associated with porting a software project, the illustrative embodiments may evaluate one of those other phases based on its similarity to a particular phase of the plurality of phases.

[0067] Thus, the illustrative embodiments provide one or more technical solutions that overcome the technical problem that current solutions are unable to accurately predict the amount of effort required to port a software project from a source platform to a heterogeneous platform, and as a result, these one or more technical solutions provide technical effects and practical applications in the fields of software project porting and machine learning model training.

[0068] Referring now to Figure 2, a diagram illustrating an example of a porting effort prediction system is shown, according to an illustrative embodiment. The porting effort prediction system 201 may be implemented in a computing environment, such as the computing environment 100 in Figure 1. The porting effort prediction system 201 is a system of hardware and software components for accurately predicting the total effort required to port a software project from a source platform to a heterogeneous target platform using multiple machine learning models.

[0069] In this example, porting work effort prediction system 201 includes computer 202. Computer 202 may be, for example, computer 101 in FIG. 1. Computer 202 includes machine learning model 204. Machine learning model 204 may be implemented by porting work effort prediction code 200 in FIG. 1. Machine learning model 204 may be, for example, an artificial neural network, a recurrent neural network, or the like.

[0070] At 206, in response to receiving a request to determine the amount of effort required to port a software project across heterogeneous platforms, computer 202 retrieves historical data of a previously ported software project. Note that the software project may be any type of computer program. At 208, computer 202 extracts feature data corresponding to each phase of phases 210 from the historical data of the previously ported software project. Phases 210 are associated with stages for porting the software project. In this example, phases 210 include a configuration phase 212, a compilation phase 214, a linking phase 216, a code modification phase 218, a testing phase 220, and a bug fixing phase 222.

[0071] At 224, the computer 202 trains machine learning models 204, including machine learning model 1 226, machine learning model 2 228, machine learning model 3 230, machine learning model 4 232, machine learning model 5 234, and machine learning model 6 236, using feature data corresponding to phase 210. For example, the computer 202 trains machine learning model 1 226 to predict the base porting effort (E1) using feature data from the configuration phase 212, the compilation phase 214, the linking phase 216, the code modification phase 218. The computer 202 trains machine learning model 2 228 to predict the number of new test cases using feature data from the configuration phase 212, the compilation phase 214, the linking phase 216, the code modification phase 218, and the testing phase 220, including the number of original test cases used.

[0072] The computer 202 trains machine learning model 3 230 to predict testing effort (E2) using feature data of the predicted number of new test cases in the testing phase 220. The computer 202 trains machine learning model 4 232 to predict the number of bugs using feature data from the configuration phase 212, the compilation phase 214, the linking phase 216, the code modification phase 218, and the testing phase 220.

[0073] The computer 202 trains machine learning model 5 234 to predict the bug fixing effort (E3) using feature data of the predicted number of bugs in the bug fixing phase 222. The computer 202 trains machine learning model 6 239 to predict the total porting effort (ET) using the base porting effort (E1), the testing effort (E2), and the bug fixing effort (E3). The computer 202 can port the software project from the source platform to a heterogeneous target platform using the trained machine learning models 226-236 if the total porting effort (ET) is less than a defined maximum porting effort threshold level.

[0074] 3, a diagram illustrating an example of a machine learning training process is shown, according to an example embodiment. The machine learning training process 300 is implemented in a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2.

[0075] In this example, machine learning training process 300 begins at 302, where a computer retrieves past porting software project data. At 304, the computer extracts feature data from the past porting software project data from multiple phases, such as phase 210 in Figure 2. At 306, the computer inputs the feature data as training data into multiple machine learning models, such as machine learning model 204 in Figure 2.

[0076] For example, at 308, the computer trains machine learning model 1 to predict the base porting effort (E1) using specific feature data corresponding to a specific phase. At 310, the computer trains machine learning model 2 to predict the number of new test cases using specific feature data corresponding to a specific phase. At 312, the computer trains machine learning model 3 to predict the testing effort (E2) using feature data corresponding to a specific phase. At 314, the computer trains machine learning model 4 to predict the number of bugs using specific feature data corresponding to a specific phase. At 316, the computer trains machine learning model 5 to predict the bug fixing effort (E3) using feature data corresponding to a specific phase. At 318, the computer trains machine learning model 6 to predict the total porting effort (ET) using the base porting effort (E1), the testing effort (E2), and the bug fixing effort (E3).

[0077] 4, a diagram illustrating an example of a porting effort prediction process is shown, in accordance with an exemplary embodiment. Porting effort prediction process 400 is implemented in a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2.

[0078] In this example, the porting effort prediction process 400 begins at 402, where a computer retrieves past porting software project data. At 404, the computer extracts feature data 406 from the past porting software project data by multiple phases, such as phase 210 in FIG. 2.

[0079] At 408, the computer uses machine learning model 1 to predict the base porting effort (E1) using a specific portion of the feature data 406 corresponding to a specific phase. At 410, the computer uses machine learning model 2 to predict the number of new test cases using a specific portion of the feature data 406 corresponding to a specific phase. At 412, the computer uses machine learning model 3 to predict the testing effort (E2) using a specific portion of the feature data 406 corresponding to a specific phase. At 414, the computer uses machine learning model 4 to predict the number of bugs using a specific portion of the feature data 406 corresponding to a specific phase. At 416, the computer uses machine learning model 5 to predict the bug fixing effort (E3) using a specific portion of the feature data 406 corresponding to a specific phase. At 418, the computer uses machine learning model 6 to predict the total porting effort (ET) using the base porting effort (E1), the testing effort (E2), and the bug fixing effort (E3).

[0080] 5, a diagram illustrating an example of a porting effort forecast table is shown, according to an exemplary embodiment. Porting effort forecast table 500 is implemented on a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2, using, for example, porting effort forecast code 200 in FIG. 1. In this example, porting effort forecast table 500 includes phase 210, feature data 504, feature data index 506, porting effort identifier 508, and an exemplary number of porting efforts 510.

[0081] In response to the computer retrieving the historical data corresponding to the previously ported software projects, the computer categorizes the historical data by each of the different phases in phase 210. Phase 210 includes a configuration phase 212, a compilation phase 214, a linking phase 216, a code modification phase 218, a testing phase 220, and a bug fixing phase 222. In addition, the computer retrieves historical effort records corresponding to the previously ported software projects. The historical effort records may include, for example, the amount of time spent for each phase during the original construction of the software projects, the type of programming language associated with each software project, the type of platform on which each software project was originally built, the type of platform to which each software project was previously ported, and the like.

[0082] Next, the computer identifies feature data 504 corresponding to each phase of the phases 210 based on the classification of the past data by different phases. For example, the feature data 504 may include configuration code 512 (e.g., lines of configuration code in a configuration file) corresponding to the configuration phase 212; compilation commands 514 (e.g., lines of code in a make file) corresponding to the compilation phase 214; linkage commands 516 (e.g., lines of code in a header file) corresponding to the link phase 216; source code 518 (e.g., lines of code in a source code file) corresponding to the code modification phase 218; number of original test cases 520 (e.g., the number of test cases executed during the construction of the software project) corresponding to the testing phase 220; number of new test cases 522 (e.g., the number of new test cases required to port the software project to a different type of platform) corresponding to the testing phase 220; and number of bugs 524 (e.g., the number of bugs predicted to be found during the execution of the number of new test cases) corresponding to the bug fixing phase 222. However, if feature data for a particular phase is not available, the computer can use zero filling for the feature data corresponding to that particular phase.

[0083] 6, a diagram illustrating an example of a base porting effort prediction process is shown, according to an exemplary embodiment. Base porting effort prediction process 600 is implemented in a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2, using, for example, porting effort prediction code 200 in FIG. 1.

[0084] At 602, the computer trains machine learning model 1 226 to predict base porting effort (E1). Based on a group of phases including configuration phase 212 (feature data index x1), compilation phase 214 (feature data index x2), linking phase 216 (feature data index x3), and code modification phase 218 (feature data index x4), the computer determines a prediction function: E1 = f(x1, x2, x3, x4), where E1 is the predicted base porting effort corresponding to the group of phases. By examining historical data corresponding to previously ported software projects, the computer learned that software project size and porting effort have a linear or approximately linear relationship, as shown in relationship graph 604. Relationship graph 604 includes software project size 606 as the x-axis and porting effort 608 as the y-axis, with the curve illustrating the relationship between software project size and porting effort.

[0085] Based on the relationship graph 604, the computer uses the best-fit curve to predict the base porting effort (E1) corresponding to the group of phases above. Note that the computer can use any existing curve-fitting method to find the best-fit curve.

[0086] 7, a diagram illustrating an example of a process for predicting the number of new test cases is shown, according to an illustrative embodiment. Process 700 for predicting the number of new test cases is implemented on a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2, using, for example, porting effort prediction code 200 in FIG. 1.

[0087] The computer trains machine learning model 2 228 to predict the number of new test cases required based on the number of original test cases 520 (feature data index x5) for test phase 220, along with feature data corresponding to the configuration phase (feature data index x1), the compilation phase (feature data index x2), the linking phase (feature data index x3), and the code modification phase (feature data index x4). The computer then determines a number of new test cases prediction function: x6 = f(x1, x2, x3, x4, x5), where x6 is the predicted number of new test cases required to port the software project to a heterogeneous target platform. The computer then utilizes the trained machine learning model 2 228 to predict the number of new test cases required (feature data index x6) using feature data 504 corresponding to a group of phases including configuration (x1), compilation (x2), linking (x3), code modification (x4), and testing (x5) (i.e., the number of original test cases used).

[0088] The computer then trains the machine learning model 3 based on the number of original test cases 520 (x5) (i.e., the number of original test cases used) and the number of new test cases 522 (x6) (i.e., the predicted number of new test cases required). Thus, the trained machine learning model 3 can predict the second porting effort (E2) corresponding to the testing phase 220 using a prediction function: E2=f(x5+x6), where x5 is the number of original test cases 520 and x6 is the predicted number of new test cases 522. It should be noted that the computer can use any existing method to find the best prediction function.

[0089] 8, a diagram illustrating an example of a bug count prediction process is shown, according to an illustrative embodiment. Bug count prediction process 800 is implemented on a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2, using, for example, porting effort prediction code 200 in FIG. 1.

[0090] The computer trains machine learning model 4 232 to predict the number of bugs detected during execution of the test cases based on feature data corresponding to a group of phases including a configuration phase (x1), a compilation phase (x2), a linking phase (x3), and a code modification phase (x4), along with the number of original test cases used (x5) and the predicted number of new test cases required (x6). The computer then determines a prediction function: x7 = f(x1, x2, x3, x4, (x5 + x6)), where x7 is the predicted number of bugs that will be detected during execution of the test cases during porting. The computer then uses the trained machine learning model 4 232 to predict the number of bugs 524 (x7) (i.e., the number of bugs detected) using feature data corresponding to a group of phases including a configuration (x1), a compilation (x2), a linking (x3), and a code modification (x4), along with the number of original test cases used (x5) and the predicted number of new test cases required (x6).

[0091] The computer then trains the machine learning model 5 based on the number of bugs 524(x7) (i.e., the predicted number of detected bugs). Thus, the trained machine learning model 5 can predict the third porting effort (E3), which corresponds to the amount of effort required to fix the detected bugs, using a prediction function: E3=f(x7), where x7 is the predicted number of bugs. Note that the computer can use any existing method to find the best prediction function.

[0092] 9, a diagram illustrating an example of a total porting effort prediction process is shown, in accordance with an illustrative embodiment. The total porting effort prediction process 900 is implemented in a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2, using, for example, porting effort prediction code 200 in FIG. 1.

[0093] In response to the computer predicting the first porting effort (i.e., base porting effort) (E1 904), the second porting effort (i.e., testing effort) (E2 906), and the third porting effort (i.e., bug fix effort) (E3 908) using machine learning model 1, machine learning model 2, machine learning model 3, machine learning model 4, and machine learning model 5, the computer trains machine learning model 6 236 to predict the total porting effort (ET912) required to port the software project to a heterogeneous target platform using the first porting effort (E1 904), the second porting effort (E2 906), and the third porting effort (E3 908).

[0094] Thus, the computer determines a total porting effort prediction function: ET=f(E1, E2, E3), where ET is the predicted total porting effort for porting the software project to a heterogeneous target platform. Note that the total porting effort (ET 912) may be a weighted value. The computer may, for example, utilize a neural network to determine and apply a weight to each of E1 904, E2 906, and E3 908. Because porting may also include other phases, such as, for example, design, documentation, construction, review, and the like, which are relatively minor, and because some past effort records used as training data for one or more machine learning models may not be very accurate, the computer may utilize machine learning to predict the total porting effort (ET 912) instead of simply summing E1 904, E2 906, and E3 908.

[0095] 10A-10C, a flowchart illustrating a process for predicting porting effort according to an exemplary embodiment is shown. The process illustrated in FIGS. 10A-10C may be implemented in a computer, such as computer 101 in FIG. 1 or computer 202 in FIG. 2. For example, the process illustrated in FIGS. 10A-10C may be implemented by porting effort prediction code 200 in FIG. 1.

[0096] The process begins when a computer receives a request to port a software project from a source platform to a heterogeneous target platform (step 1002). In response to the request, the computer retrieves from a database a set of historical data corresponding to similar software projects that have previously been ported to a similar target platform (step 1004).

[0097] The computer performs an analysis of a set of historical data corresponding to similar software projects previously ported to a similar target platform (step 1006). The computer extracts, from the set of historical data based on the analysis of the set of historical data corresponding to similar software projects previously ported to a similar target platform (step 1008), characteristic data for each of a plurality of phases associated with the software project porting process. The plurality of phases include a configuration phase, a compilation phase, a linking phase, a code modification phase, a testing phase, and a bug fixing phase.

[0098] The computer trains a first machine learning model to predict a first porting effort (E1) using feature data corresponding to the configuration phase, the compilation phase, the linking phase, and the code modification phase (step 1010). The computer trains a second machine learning model to predict a number of new test cases required using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and a test phase, including the number of original test cases used during the initial construction of the software project (step 1012).

[0099] The computer trains a third machine learning model to predict a second porting effort (E2) using the predicted number of required new test cases included in the feature data corresponding to the test phase (step 1014). The computer trains a fourth machine learning model to predict the number of bugs detected during execution of the number of original test cases and the predicted number of required new test cases using the feature data corresponding to the configure phase, compile phase, link phase, code modify phase, and test phase (step 1016).

[0100] The computer trains a fifth machine learning model to predict a third porting effort (E3) using the predicted number of detected bugs included in the feature data corresponding to the bug fixing phase (step 1018). The computer trains a sixth machine learning model to predict a total porting effort (ET) using the first porting effort (E1), the second porting effort (E2), and the third porting effort (E3) (step 1020).

[0101] The computer utilizes a first machine learning model to predict a first porting effort (E1) using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase (step 1022). The computer utilizes a second machine learning model to predict a number of new test cases required using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a test phase, including the number of original test cases used during the initial construction of the software project (step 1024).

[0102] The computer uses a third machine learning model to predict a second porting effort (E2) using the predicted number of required new test cases included in the feature data corresponding to the test phase (step 1026).The computer uses a fourth machine learning model to predict the number of bugs that will be detected during execution of the number of original test cases and the predicted number of required new test cases using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the test phase (step 1028).

[0103] The computer uses the fifth machine learning model to predict a third porting effort (E3) using the predicted number of detected bugs included in the feature data corresponding to the bug fixing phase (step 1030). The computer uses the sixth machine learning model to predict a total porting effort (ET) required to port the software project from the source platform to the heterogeneous target platform using the first porting effort (E1), the second porting effort (E2), and the third porting effort (E3) (step 1032). The first porting effort (E1) is the base porting effort, the second porting effort (E2) is the testing effort, and the third porting effort (E3) is the bug fixing effort. The computer ports the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than the defined maximum porting effort threshold level (step 1034). The process then ends.

[0104] Thus, exemplary embodiments of the present disclosure provide a computer-implemented method, computer system, and computer program product for predicting porting effort. While the descriptions of various embodiments of the present disclosure have been presented for illustrative purposes, they are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been selected to best explain the principles, practical applications, or technical improvements of the embodiments over technologies found in the marketplace, or to enable others skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A computer-implemented method for estimating porting effort, comprising: predicting, by the computer, a total porting effort for porting the software project from the source platform to the heterogeneous target platform using the first porting effort, the second porting effort, and the third porting effort, utilizing a sixth machine learning model; and porting the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level.

1. A computer-implemented method comprising:

2. a step in which the computer predicts the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase, by using a first machine learning model; The computer-implemented method of claim 1 further comprising:

3. The computer utilizes a second machine learning model to predict the number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase, including the number of original test cases used during construction of the software project; and a step in which the computer predicts the second porting effort using a predicted number of new test cases included in feature data corresponding to the test phase, by using a third machine learning model; The computer-implemented method of claim 1 or 2, further comprising:

4. the computer utilizing a fourth machine learning model to predict the number of bugs that will be detected during execution of the number of original test cases and the predicted number of new test cases using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the test phase; and a step in which the computer predicts the third porting effort using a predicted number of bugs to be detected, the number being included in feature data corresponding to a bug fixing phase, by using a fifth machine learning model; The computer-implemented method of claim 1 or 2, further comprising:

5. 3. The computer-implemented method according to claim 1, wherein the first porting effort is a base porting effort, the second porting effort is a testing effort, and the third porting effort is a bug fixing effort.

6. receiving, by the computer, a request to port the software project from the source platform to the heterogeneous target platform; retrieving, by the computer in response to the request, a set of historical data corresponding to similar software projects previously ported to a similar target platform; performing, by the computer, an analysis of the historical data set corresponding to the similar software projects previously ported to the similar target platform; and extracting, by the computer, from the set of historical data based on the analysis of the set of historical data corresponding to the similar software projects previously ported to the similar target platform, feature data for each of a plurality of phases associated with a software project porting process, the plurality of phases including a configuration phase, a compilation phase, a linking phase, a code modification phase, a testing phase, and a bug fixing phase; The computer-implemented method of claim 1 or 2, further comprising:

7. training a first machine learning model to predict the first porting effort using the feature data corresponding to the configuration phase, the compilation phase, the linking phase, and the code modification phase; The computer-implemented method of claim 6 further comprising:

8. training a second machine learning model to predict the number of new test cases using the feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the testing phase, including the number of original test cases used during construction of the software project; and training a third machine learning model by the computer to predict the second porting effort using the number of new test cases included in the feature data corresponding to the test phase; The computer-implemented method of claim 6 further comprising:

9. training a fourth machine learning model to predict the number of bugs detected during execution of a number of original test cases and a predicted number of new test cases using the feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the testing phase; and training a fifth machine learning model by the computer to predict the third porting effort using the number of detected bugs included in the feature data corresponding to the bug fixing phase; The computer-implemented method of claim 6 further comprising:

10. training the sixth machine learning model to predict the total porting effort using the first porting effort, the second porting effort, and the third porting effort. The computer-implemented method of claim 6 further comprising:

11. 1. A computer system for estimating porting effort, comprising: communications fabric; a set of computer-readable storage media coupled to the communications fabric, the set of computer-readable storage media collectively storing program instructions; and a set of processors connected to said communications fabric wherein the set of processors executes the program instructions to: utilizing a sixth machine learning model to predict a total porting effort for porting the software project from the source platform to the heterogeneous target platform using the first porting effort, the second porting effort, and the third porting effort; porting the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level; Computer system.

12. The set of processors further executes the program instructions to: predicting the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase using a first machine learning model; 12. The computer system of claim 11.

13. The set of processors further executes the program instructions to: Utilizing a second machine learning model to predict a number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase, including a number of original test cases used during construction of the software project; predicting the second porting effort using a third machine learning model based on the predicted number of new test cases included in the feature data corresponding to the test phase; 13. A computer system according to claim 11 or 12.

14. The set of processors further executes the program instructions to: Utilizing a fourth machine learning model to predict the number of bugs that will be detected during execution of the number of original test cases and the predicted number of new test cases using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the testing phase; predicting the third porting effort using a fifth machine learning model, using a predicted number of bugs to be detected, which is included in the feature data corresponding to the bug fixing phase; 13. A computer system according to claim 11 or 12.

15. 13. The computer system according to claim 11, wherein the first porting work man-hours are base porting work man-hours, the second porting work man-hours are testing work man-hours, and the third porting work man-hours are bug fixing work man-hours.

16. 1. A computer program for predicting porting effort, the computer program comprising: utilizing a sixth machine learning model to predict a total porting effort for porting the software project from the source platform to the heterogeneous target platform using the first porting effort, the second porting effort, and the third porting effort; and porting the software project from the source platform to the heterogeneous target platform based on the total porting effort being less than a defined maximum porting effort threshold level. A computer program for executing

17. On the computer: predicting the first porting effort using feature data corresponding to a configuration phase, a compilation phase, a linking phase, and a code modification phase, using a first machine learning model; 17. The computer program of claim 16, further comprising:

18. On the computer: utilizing a second machine learning model to predict the number of new test cases using feature data corresponding to a configuration phase, a compilation phase, a linking phase, a code modification phase, and a testing phase, including the number of original test cases used during construction of the software project; and a step of predicting the second porting effort using a third machine learning model and a predicted number of new test cases included in the feature data corresponding to the test phase; 18. A computer program according to claim 16 or 17, further comprising:

19. On the computer: utilizing a fourth machine learning model to predict the number of bugs that will be detected during execution of the original number of test cases and the predicted number of new test cases using feature data corresponding to the configuration phase, the compilation phase, the linking phase, the code modification phase, and the test phase; and a step of predicting the third porting effort using a fifth machine learning model and a predicted number of bugs to be detected, the number being included in the feature data corresponding to the bug fixing phase; 18. A computer program according to claim 16 or 17, further comprising:

20. 18. The computer program according to claim 16, wherein the first porting effort is a base porting effort, the second porting effort is a testing effort, and the third porting effort is a bug fixing effort.

Images