Computer-implemented method, computer program product, and computer system for identifying the use of deprecated software source code in software repositories (machine learning-based deprecated software identification)

Abstract

To provide a computer implementation method, a computer programming product and a computer system that identify use of a non-recommended software source code in a software repository.SOLUTION: An approach that identifies and recommends use of a non-recommended source code in a software repository comprises steps of: analyzing one or more software repositories for a software source code identified as non-recommendation by a machine learning model 502: alerting, in response to identifying the non-recommended software source code, one or more first software developers responsible for maintaining a software source code module using the non-recommended software source code 504; and recommending, to the one or more first software developers, an alternative software source code to be used in the software source code module to replace the non-recommended software source code 506.SELECTED DRAWING: Figure 5

Description

[Technical Field]

[0001] The present invention relates generally to software maintenance, and more specifically to tracking deprecated software and providing usage-based software testing guidance. [Background technology]

[0002] Software, programming languages, and their respective libraries undergo spontaneous changes during development, requiring software development teams to update their code to the latest versions. If software development teams are unable to keep up with these changes due to misinformed priorities or resource constraints, they may expose their code to software vulnerabilities. Furthermore, software testing is a perpetual task that increases the time between software releases and drains resources from other software-related tasks.

[0003] What is missing in the software development field are tools to track shared software usage across an organization with respect to the use and removal of deprecated software modules, predictions regarding software components, and predictions regarding the amount of testing required to believe that a particular software module has been adequately tested before being released in a product or as a library. Summary of the Invention [Problem to be solved by the invention]

[0004] A computer-implemented method, computer program product, and computer system for identifying the use of deprecated software source code in a software repository are provided. [Means for solving the problem]

[0005] According to one embodiment of the present invention, a computer-implemented method for identifying use of deprecated software source code in software repositories includes: performing, by one or more processors, an analysis of one or more software repositories for software source code identified as deprecated by a machine learning model; in response to identifying the deprecated software source code, alerting, by the one or more processors, a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code; and recommending, by the one or more processors, to the first one or more software developers alternative software source code to use in the software source code modules to replace the deprecated software source code.

[0006] According to one embodiment of the present invention, there is provided a computer program product for identifying use of deprecated software source code in software repositories, the computer program product including: one or more non-transitory computer-readable storage media; and program instructions stored on the one or more non-transitory computer-readable storage media, the program instructions including: performing an analysis of one or more software repositories for software source code identified as deprecated by a machine learning model; alerting a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code in response to identifying the deprecated software source code; and recommending to the first one or more software developers alternative software source code to use in the software source code modules to replace the deprecated software source code.

[0007] According to one embodiment of the present invention, a computer system for identifying use of deprecated software source code in software repositories includes one or more computer processors, one or more computer-readable storage media, and program instructions stored on the one or more computer-readable storage media for execution by at least one of the one or more computer processors, the program instructions including: program instructions for performing an analysis of one or more software repositories for software source code identified as deprecated by a machine learning model; program instructions for alerting a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code in response to identifying the deprecated software source code; and program instructions for recommending to the first one or more software developers alternative software source code to use in the software source code modules to replace the deprecated software source code.

[0008] Other aspects and embodiments of the present invention will become apparent from the following detailed description, which, when taken in conjunction with the drawings, illustrate by way of example the principles of the invention. [Brief explanation of the drawings]

[0009] [Figure 1] FIG. 1 illustrates a cloud computing environment according to an embodiment of the present invention. [Figure 2] FIG. 2 illustrates abstract model layers according to an embodiment of the present invention. [Figure 3] FIG. 3 is a high-level architecture according to an embodiment of the present invention. [Figure 4] FIG. 4 is an exemplary detailed architecture according to an embodiment of the present invention. [Figure 5] FIG. 5 is a flowchart of a method according to an embodiment of the present invention. [Figure 6]FIG. 6 is a block diagram of internal and external components of a data processing system in which embodiments described herein may be implemented in accordance with embodiments of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0010] The following description is made for the purpose of illustrating the general principles of the present invention and is not intended to limit the inventive concepts claimed herein. Moreover, particular features described herein can be used in combination with other described features in each of the various possible combinations and permutations.

[0011] Unless otherwise defined herein, all terms should be given the broadest possible interpretation, including the meaning implied from this specification and the meaning understood by a person skilled in the art or defined in dictionaries, treatises, etc., or both.

[0012] As used herein, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly dictates otherwise. As used herein, the term "comprises" and / or "comprising" specifies the presence of stated features, integers, steps, operations, elements, or components, or combinations thereof, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, or groups or combinations thereof.

[0013] The following description discloses several embodiments for identifying deprecated modules of source code, redundant modules of source code, and predicted test levels required for modules of source code based on their usage across the enterprise. Note that the term software, as used herein, includes any type of computer instructions, such as, but not limited to, firmware, microcode, etc.

[0014] Embodiments of the present invention can provide machine learning-based predictions of segments of deprecated source code. The predictions can include potential solutions, i.e., source code for replacing the deprecated source code, based on source code that replaces the same or similar source code in other parts of the same application or a different application. Embodiments can use static source code to train the model and do not insert deprecated source code for training.

[0015] In another aspect, embodiments may provide a prediction regarding the amount of testing required for source code that replaces deprecated source code, where the amount of testing is based on factors such as, but not limited to, the number of places the replacement source code is used, the length of time the replacement source code has been deployed in similar areas of functionality, and the amount of calls to the replacement source code.

[0016] In one general embodiment, a computer-implemented method includes: performing, by one or more processors, an analysis of one or more software repositories for software source code identified by a machine learning model as deprecated; and in response to identifying the deprecated software source code, alerting, by the one or more processors, one or more software developers responsible for maintaining software source code modules that include the deprecated software source code; and recommending, by the one or more processors, alternative software source code for use in the software source code modules to replace the deprecated software source code.

[0017] In another general embodiment, a system includes a processor and logic integrated with, executable by, or integrated with and executable by the processor, the logic configured to perform the computer-implemented method described above.

[0018] In another general embodiment, a computer program product for installation-time software validation includes a computer-readable storage medium having program instructions embodied therein that are executable by a computer to cause the computer to perform the computer-implemented method described above.

[0019] Although this disclosure includes detailed descriptions of cloud computing, implementation of the teachings described herein is not limited to cloud computing environments. Rather, embodiments of the invention can be practiced in conjunction with any other type of computing environment now known or later developed.

[0020] Cloud computing is a service delivery model for enabling convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with the service provider. This cloud model may include at least five characteristics, at least three service models, and at least four implementation models.

[0021] The characteristics are as follows:

[0022] On-Demand Self-Service: Cloud consumers can unilaterally provision computing capacity, such as server time or network storage, automatically as needed, without the need for human interaction with the service provider.

[0023] Broad network access: Computing power is available over the network and can be accessed through standard mechanisms, facilitating use by heterogeneous thin or thick client platforms (e.g., cell phones, laptops, PDAs).

[0024] Resource Pooling: Computing resources from a provider are pooled and offered to multiple consumers using a multi-tenant model. Various physical and virtual resources are dynamically allocated and reallocated based on demand. Consumers generally have no control or knowledge of the exact location of the resources they are provided with, so there is a sense of location independence. However, consumers may be able to identify their location at a higher level of abstraction (e.g., country, state, data center).

[0025] Rapid Elasticity: Computing capacity can be provisioned quickly and elastically, sometimes automatically, to instantly scale out and quickly released to instantly scale in. To the consumer, the computing power available to provision often appears unlimited, and can be purchased at any time and in any quantity.

[0026] Metered Services: Cloud systems leverage measurement capabilities at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, active user accounts) to automatically control and optimize resource usage. Resource usage can be monitored, controlled, and reported to provide transparency to both providers and consumers of utilized services.

[0027] The service model is as follows:

[0028] Software as a Service (SaaS): The functionality offered to the consumer is the use of a provider's applications running on a cloud infrastructure. The applications can be accessed from a variety of client devices through a thin-client interface such as a web browser (e.g., webmail). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application functionality, except for limited user-specific application configuration settings.

[0029] Platform as a Service (PaaS): The capability offered to consumers is to deploy applications they create or acquire onto a cloud infrastructure using programming languages ​​and tools supported by the provider. The consumer does not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the configuration of their hosting environment.

[0030] Infrastructure as a Service (IaaS): The functionality provided to consumers is the provisioning of processors, storage, networking, and other basic computing resources on which the consumer can deploy and run any software, including operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but has control over the operating systems, storage, and deployed applications, and in some cases partial control over some network components (e.g., host firewalls).

[0031] The deployment model is as follows:

[0032] Private Cloud: This cloud infrastructure is dedicated to a specific organization and can be managed by that organization or a third party, and can exist on-premise or off-premise.

[0033] Community Cloud: This cloud infrastructure is shared by multiple organizations to support a specific community with common concerns (e.g., mission, security requirements, policies, and compliance). This cloud infrastructure can be managed by those organizations or a third party and can exist on-premises or off-premises.

[0034] Public cloud: This cloud infrastructure is available to the general public or large industry organizations and is owned by an organization that sells cloud services.

[0035] Hybrid cloud: This cloud infrastructure combines two or more cloud models (private, community, or public), each of which retains its inherent nuances but is bound by standards or specific technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0036] A cloud computing environment is a service-oriented environment that emphasizes statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is an infrastructure that includes a network of interconnected nodes.

[0037] FIG. 1 illustrates an exemplary cloud computing environment 50. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10, with which local computing devices used by cloud consumers (e.g., PDAs or cell phones 54A, desktop computers 54B, laptop computers 54C, or automobile computer systems 54N, or combinations thereof) can communicate. The nodes 10 can communicate with each other. The nodes 10 can be physically or virtually grouped (not shown) in one or more networks, such as the private, community, public, or hybrid clouds described above, or combinations thereof. This enables the cloud computing environment 50 to provide infrastructure, platform, or software as a service, or combinations thereof, for which cloud consumers are not required to maintain resources on their local computing devices. It should be understood that the types of computing devices 54A-N illustrated in FIG. 1 are merely exemplary, and that the computing nodes 10 and the cloud computing environment 50 can communicate with any type of electronic device via any type of network or network-addressable connection (e.g., using a web browser), or both.

[0038] A set of functional abstraction layers provided by cloud computing environment 50 (FIG. 1) is now shown in FIG. 2. It should be understood in advance that the components, layers, and functions shown in FIG. 2 are merely exemplary, and embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0039] Hardware and software layer 60 includes hardware and software components. Examples of hardware components include mainframe 61, reduced instruction set computer (RISC) architecture-based server 62, server 63, blade server 64, storage device 65, and network and network components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0040] The virtualization layer 70 provides an abstraction layer from which the following virtual entities can be provided, for example: virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75.

[0041] By way of example, the management layer 80 may provide the following functions: Resource provisioning 81 enables dynamic procurement of computing and other resources utilized to execute tasks within the cloud computing environment; Metering and pricing 82 enables cost tracking as resources are utilized within the cloud computing environment and billing or invoicing for the consumption of these resources; By way of example, these resources may include application software licenses; Security enables identification and verification of cloud consumers and tasks, as well as protection for data and other resources; User portal 83 provides consumers and system administrators with access to the cloud computing environment; Service level management 84 enables allocation and management of cloud computing resources so that requested service levels are met; Service level agreement (SLA) planning and fulfillment 85 enables advance arrangement and procurement of anticipated future cloud computing resources required in accordance with SLAs.

[0042] The workload layer 90 provides examples of functionality available to a cloud computing environment. Examples of workloads and functionality that can be provided from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom instruction delivery 93, data analytics processing 94, transaction processing 95, and automated discovery and cataloging or inventorying of items or assets at a location or property 96.

[0043] It should be noted that embodiments of the present invention may operate with user permission, such that data may be collected, stored, analyzed, etc. In various configurations, at least some embodiments of the present invention are implemented as opt-in applications, plug-ins, etc., as will be understood by those of skill in the art upon reading this disclosure.

[0044] Figure 3 is a high-level architecture for performing the various operations of Figure 5, according to various embodiments. Architecture 300 may be implemented in accordance with the present invention in various embodiments, particularly in any of the environments shown in Figures 1-4. Of course, more or fewer elements than those specifically depicted in Figure 3 may be included in architecture 300, as will be understood by those skilled in the art upon reading this description.

[0045] Each step of method 500 (described in further detail below) may be performed by any suitable component of architecture 300. A processor (e.g., a processing circuit, chip, or module, or a combination thereof), implemented in hardware or software or both, and preferably having at least one hardware component, may be utilized in any device to perform one or more steps of method 500 of architecture 300. Exemplary processors include, but are not limited to, a central processing unit (CPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), or the like, combinations thereof, or any other suitable computing device known in the art.

[0046] Architecture 300 includes a block diagram illustrating an exemplary processing system for identifying deprecated modules of source code, redundant modules of source code, and predicted test levels required for modules of source code based on an enterprise-wide usage environment to which the principles of the present invention may be applied. Architecture 300 includes a client computer 302, a deprecated source code prediction component 308 operable on a server computer 304, and a network 306 supporting communication between client computer 302 and server computer 304.

[0047] Client computer 302 may be any computing device on which software updates are desired or required. Client computer 302 may be a standalone computing device, an administrative server, a web server, a mobile computing device, or any other electronic device or computing system capable of receiving, transmitting, and processing data. In other embodiments, client computer 302 may represent a server computing system that utilizes multiple computers as a server system. In another embodiment, client computer 302 may be a laptop computer, a tablet computer, a netbook computer, a personal computer, a desktop computer, or any programmable electronic device capable of communicating with other computing devices (not shown) in the user persona generation environment via network 306.

[0048] In another embodiment, client computer 302 represents a computing system utilizing clustered computers and components (e.g., database server computers, application server computers, etc.) that function as a single pool of seamless resources when accessed within the installation-time validation environment of architecture 300. Client computer 302 may include internal and external hardware components, as shown and described in further detail in connection with FIG.

[0049] Server computer 304 may be a standalone computing device, an administrative server, a web server, a mobile computing device, or any other electronic device or computing system capable of receiving, transmitting, and processing data. In other embodiments, server computer 304 may represent a server computing system that utilizes multiple computers as a server system. In another embodiment, server computer 304 may be a laptop computer, a tablet computer, a netbook computer, a personal computer, a desktop computer, or any programmable electronic device capable of communicating with other computing devices (not shown) within the installation-time validation environment of architecture 300 via network 306.

[0050] The network 306 may be, for example, a local area network (LAN), a wide area network (WAN) such as the Internet, or a combination thereof, and may include wired, wireless, or fiber optic connections. In general, the network 306 may be any combination of connections and protocols that support communication between the client computer 302 and the server computer 304.

[0051] The deprecated source code prediction component 308, operating on the server computer 304, can locate sections of deprecated source code within a software repository based on machine learning of software developers responsible for the source code that has been or will be deprecated. The deprecated source code prediction component 308 can make manual or automated decisions regarding the identification and scope of the deprecated source code. Based on the predicted identification of the deprecated source code, the deprecated source code prediction component 308 can recommend replacements for the deprecated source code based on replacement source code used in areas where the deprecated source code has already been replaced.

[0052] In another aspect, the deprecated source code prediction component 308 can provide predictions regarding the level of unit and functional testing required for source code recommended to replace the deprecated source code. The recommendations provided by the deprecated source code prediction component 308 can be a starting point for implementing a test plan for updated test procedures based on following the implementation of the recommended replacement for the deprecated source code.

[0053] Figure 4 is an exemplary detailed architecture for performing the various operations of Figure 5, according to various embodiments. Architecture 400 may be implemented in accordance with the present invention in various embodiments, particularly in any of the environments shown in Figures 1-3 and 5. Of course, more or fewer elements than those specifically depicted in Figure 4 may be included in architecture 400, as will be understood by those skilled in the art upon reading this description.

[0054] Each step of method 500 (described in further detail below) may be performed by any suitable component of architecture 400. A processor (e.g., a processing circuit, chip, or module, or a combination thereof), implemented in hardware or software or both, and preferably having at least one hardware component, may be utilized in any device to perform one or more steps of method 500 of architecture 400. Exemplary processors include, but are not limited to, a central processing unit (CPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), or the like, combinations thereof, or any other suitable computing device known in the art.

[0055] Architecture 400 provides a detailed view of at least some modules of architecture 300. Architecture 400 can include a deprecated source code prediction component 308 and can further include a deprecated source code parser component 402 and a deprecated source code replacement component 404.

[0056] The deprecated source code parser component 402 can search enterprise-wide source code repositories for deprecated source code by using a machine learning model to scan and analyze the enterprise-wide source code repositories and perform comparative testing based on the results. The machine learning model used by the deprecated source code parser component 402 can use static code for training. Note that the deprecated source code parser component 402 does not input deprecated source code to train the model. In one aspect, the deprecated source code parser component 402 can use a predetermined mapping of usages of software source code modules that are later identified as deprecated, prepared by manual software developer input, as a supplemental search list. In another aspect, the deprecated source code parser component 402 can create a metadata document summarizing the deprecated software and / or system components.

[0057] In another aspect, the deprecated source code parser component 402 can identify deprecated source code based on a comparison of one repository with another repository with respect to source code functionality. For example, the deprecated source code parser component 402 can identify functionally equivalent portions of code in different repositories and use source code modification dates from the repositories to determine which portions are more recent. The deprecated source code parser component 402 can then go back in time in the source code repository with newer, functionally equivalent software to determine whether the newer source code has replaced source code still in use in the software repository with older software source code.

[0058] The deprecated source code replacement component 404 can recommend predicted replacements for the deprecated software source code based on software source code that the machine learning model has discovered replacing the deprecated software source code elsewhere in the current repository or in other repositories accessible to the machine learning model via the deprecated source code parser component 402. In one aspect, the deprecated source code replacement component 404 can provide recommendations based on replacement software module identifications manually entered by software developers responsible for supporting the deprecated software source code. In another aspect, the deprecated source code replacement component 404 can search public repositories for replacements for the deprecated code based on functional analysis and present a list of predicted recommendations for evaluation. Additionally, the deprecated source code replacement component 404 can utilize the machine learning models described above to create functionally equivalent source code to replace the deprecated source code.

[0059] Additionally, the deprecated source code replacement component 404 can use the metadata document to identify appropriate software developers responsible for the identified deprecated source code and / or system components. In another aspect, the deprecated source code replacement component 404 can alert the identified software developers based on automated tools, for example, tools including continuous integration and continuous deployment pipelines.

[0060] The deprecated source code replacement component 404 can provide a visual representation to a software developer of the software source code used in the source code they are submitting to the repository. For example, the deprecated source code replacement component 404 can display a window of the source code submitted to the repository by the software developer, with sections of deprecated source code highlighted. Additionally, the deprecated source code replacement component 404 can display information advising the software developer when the deprecated source code was deprecated and why the deprecated source code was deprecated, without limitation.

[0061] The deprecated source code replacement component 404 can provide predictions of test levels, both unit and functional, suggested for source code replacements of deprecated source code. The deprecated source code replacement component 404 can make these recommendations based on data related to the recommended replacement source code, such as, but not limited to, the length of time the replacement source code has been available, the number of installed uses of the replacement source code, a quality rating of the replacement source code, the number of anomalies fixed in the replacement source code, and trends in the percentage of anomalies fixed in the replacement source code.

[0062] 5 is an example flowchart of a method 500 for identifying deprecated modules of source code, redundant modules of source code, and predicted test levels required for modules of source code based on usage across an enterprise. At step 502, an embodiment may analyze a software repository with a machine learning model to find deprecated software source code via deprecated source code parser component 402. At step 504, an embodiment may alert a software developer about the use of deprecated software source code via deprecated source code replacement component 404. At step 506, an embodiment may recommend alternative software source code to the developer via deprecated source code replacement component 404.

[0063] 6 illustrates an exemplary computer system representing computer system 600, client computer 302, and server computer 304. Computer system 600 includes a communications fabric 602 that provides communications between a computer processor 604, memory 606, persistent storage 608, a communications unit 610, and an input / output (I / O) interface 612. Communications fabric 602 may be implemented with any architecture designed to pass data and / or control information between a processor (such as a microprocessor, communications processor, or network processor), system memory, peripheral devices, and any other hardware components in the system. For example, communications fabric 602 may be implemented with one or more buses.

[0064] Computer system 600 includes a processor 604, a cache 616, a memory 606, persistent storage 608, a communication unit 610, an input / output (I / O) interface 612, and a communications fabric 602. The communications fabric 602 provides communication between the cache 616, the memory 606, the persistent storage 608, the communication unit 610, and the input / output (I / O) interface 612. The communications fabric 602 may be implemented with any architecture designed to pass data and / or control information between a processor (such as a microprocessor, communications processor, network processor, etc.), system memory, peripheral devices, and any other hardware components in the system. For example, the communications fabric 602 may be implemented with one or more buses or crossbar switches.

[0065] Memory 606 and persistent storage 608 are computer-readable storage media. In this embodiment, memory 606 includes RAM. Generally, memory 606 may include any suitable volatile or non-volatile computer-readable storage medium. Cache 616 is fast memory that improves performance of processor 604 by retaining recently accessed data and data near recently accessed data from memory 606.

[0066] Program instructions and data used to implement embodiments of the present invention may be stored in persistent storage 608 and memory 606 for execution by each of the one or more processors 604 via cache 616. In one embodiment, persistent storage 608 includes a magnetic hard disk drive. Alternatively, or in addition to a magnetic hard disk, persistent storage 608 may include a solid-state hard drive, a semiconductor memory device, a ROM, an erasable programmable ROM (EPROM), a flash memory, or any other computer-readable storage medium capable of storing program instructions or digital information.

[0067] The media used by persistent storage 608 may be removable. For example, a removable hard drive may be used for persistent storage 608. Other examples include optical disks, magnetic disks, thumb drives, and smart cards, which may be inserted into a drive for transfer to another computer-readable storage medium that is also part of persistent storage 608.

[0068] In these examples, communications unit 610 enables communication with other data processing systems or devices. In these examples, communications unit 610 includes one or more network interface cards. Communications unit 610 may enable communication using either or both physical and wireless communications links. Program instructions and data used to implement embodiments of the present invention may be downloaded to persistent storage 608 via communications unit 610.

[0069] The I / O interface 612 allows data to be input and output from other devices that may be connected to each computer system. For example, the I / O interface 612 allows connection to one or more external devices 618, such as a keyboard, keypad, touchscreen, or other suitable input device or combination thereof. The external devices 618 may also include portable computer-readable storage media, such as thumb drives, portable optical disks, portable magnetic disks, and memory cards. Software and data used to implement embodiments of the present invention may be stored on such portable computer-readable storage media and loaded into persistent storage 608 via the I / O interface 612. The I / O interface 612 also connects to a display 620.

[0070] Display 620 provides a mechanism for displaying data to a user and may be, for example, a computer monitor.

[0071] Components described herein are identified based on the application in which the programs are implemented in particular embodiments of the invention, although the names of specific components herein are used for convenience only and, therefore, the invention is not limited to use with the particular application identified and / or suggested by such names.

[0072] The present invention may be a system, method, or computer program product, or combination thereof, at any feasible level of technical detail. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions for causing a processor to perform aspects of the present invention.

[0073] A computer-readable storage medium is a tangible device that holds and stores instructions for use by an instruction execution device. Computer-readable storage media may be, for example, but are not limited to, electronic, magnetic, optical, electromagnetic, or semiconductor storage devices, or any suitable combination of the foregoing. More specific examples of computer-readable storage media include portable computer floppy disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable random access memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, coded devices such as punch cards or ridge structures with grooves on which mechanical instructions are recorded, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as a transitory signal itself, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted over a wire.

[0074] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or storage device via a network (e.g., the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof). The network may be comprised of copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface of each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage on a computer-readable storage medium within the respective computing / processing device.

[0075] Computer-readable program instructions for carrying out operations of the present invention may be either source code or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or object-oriented programming languages ​​such as Smalltalk, C++, etc., and procedural programming languages ​​such as the "C" programming language and similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, as a standalone software package, or partially on the user's computer. Alternatively, the computer may be executed partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA) can execute computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the computer-readable program instructions in order to carry out aspects of the present invention.

[0076] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0077] These computer-readable program instructions can be provided to a processor of a computer or other programmable data processing apparatus to create a machine, such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable storage media can also be stored in computer-readable storage media connectable to a computer, programmable data processing apparatus, or other device, or combination thereof, that functions in a particular way, such that the computer-readable program instructions stored therein configure one of the products, including instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0078] Computer-readable program instructions, such as instructions to perform the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams on a computer, other programmable apparatus, or other device, can also be loaded into a computer, other programmable apparatus, or other device to perform a series of operational steps on the computer, other programmable apparatus, or other device to generate a computer-implemented process.

[0079] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of executable aspects of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, which constitute one or more executable instructions for implementing the specified logical function(s). In some alternative embodiments, the functions shown in the blocks may occur out of the order shown in the figures. For example, two blocks shown in succession may actually be accomplished as a single step, executed concurrently, substantially concurrently, partially, or fully in a time-overlapping manner, or the blocks may be executed in reverse order depending on the functionality. It should also be noted that each block of the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, may be implemented by a special-purpose hardware-based system that performs the specified functions or operations or executes a combination of special-purpose hardware and computer instructions.

[0080] Furthermore, systems according to various embodiments may include a processor and logic integrated with and / or executable by the processor, the logic configured to perform one or more of the process steps described herein. "Integrated" means that the processor has logic embedded as hardware logic, such as an application-specific integrated circuit (ASIC), FPGA, etc. "Executable by the processor" means hardware logic; software logic, such as firmware, part of an operating system, or part of an application program; or any combination of hardware and software logic that is accessible by the processor and configured to cause the processor to perform some function when executed by the processor. The software logic may be stored in any memory type known in the art, local memory or remote memory, or both. Any processor known in the art may be used, for example, a software processor module, or a hardware processor, such as an ASIC, FPGA, central processing unit (CPU), integrated circuit (IC), graphics processing unit (GPU), or both.

[0081] The various features of the systems and / or methods described above can be combined in any manner, producing multiple combinations as will be apparent from the above description.

[0082] It will further be appreciated that embodiments of the present invention may be provided in the form of a service that is deployed for customers to provide services on demand.

[0083] The description of various embodiments of the present disclosure is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. It will be apparent to those skilled in the art that many modifications and variations are possible without departing from the scope and spirit of the described embodiments. The terms used herein have been selected to explain the principles of the embodiments, practical applications or technical improvements to technology found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. 1. A computer-implemented method for identifying uses of deprecated software source code in a software repository, the computer-implemented method comprising: analyzing, by one or more processors, one or more software repositories for software source code identified as deprecated by the machine learning model; In response to identifying the deprecated software source code, alerting, by the one or more processors, a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code; recommending, by the one or more processors, to the first one or more software developers alternative software source code for use in the software source code module to replace the deprecated software source code; recommending, by the one or more processors, a testing procedure for the alternative software source code. Computer-implemented methods.

2. The computer-implemented method further comprises: highlighting, by the one or more processors, the deprecated software source code. The computer-implemented method of claim 1 .

3. the alerting step further includes notifying a second one or more software developers responsible for supporting the deprecated software source code of the identity of the first one or more software developers using the deprecated software source code; The computer-implemented method of claim 1 .

4. the warning step further includes providing information to the first one or more software developers, the information including why the deprecated software source code is no longer supported and when the deprecated software source code is no longer supported; The computer-implemented method of claim 1 .

5. the alternative software source code is determined based on machine learning of multiple repositories; The computer-implemented method of claim 1 .

6. the replacement software source code is selected by a second one or more software developers responsible for supporting the deprecated software source code; The computer-implemented method of claim 1 .

7. the testing procedure is recommended based on data related to the alternative software source code, including the length of time the alternative software source code has been available, the number of installed uses of the alternative software source code, a quality rating of the alternative software source code, the number of anomalies fixed in the alternative software source code, and a trend in the rate of anomalies fixed in the alternative software source code; The computer-implemented method of claim 2 .

8. 1. A computer program product for identifying uses of deprecated software source code in a software repository, the computer program product comprising: one or more non-transitory computer-readable storage media; and program instructions stored on the one or more non-transitory computer-readable storage media, the program instructions comprising: program instructions for analyzing one or more software repositories for software source code identified as deprecated by the machine learning model; program instructions for, in response to identifying the deprecated software source code, alerting a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code; program instructions for recommending to the first one or more software developers alternative software source code for use in the software source code module to replace the deprecated software source code; and program instructions for recommending a testing procedure for the alternative software source code. Computer program products.

9. further comprising program instructions for highlighting the deprecated software source code.

9. A computer program product according to claim 8.

10. the warning further includes notifying a second one or more software developers responsible for supporting the deprecated software source code of the identity of the first one or more software developers using the deprecated software source code; 9. A computer program product according to claim 8.

11. the warning further includes providing information to the first one or more software developers including why the deprecated software source code is no longer supported and when the deprecated software source code is no longer supported.

9. A computer program product according to claim 8.

12. the alternative software source code is determined based on machine learning of multiple repositories; 9. A computer program product according to claim 8.

13. the replacement software source code is selected by a second one or more software developers responsible for supporting the deprecated software source code; 9. A computer program product according to claim 8.

14. the testing procedure is recommended based on data related to the alternative software source code, including the length of time the alternative software source code has been available, the number of installed uses of the alternative software source code, a quality rating of the alternative software source code, the number of anomalies fixed in the alternative software source code, and a trend in the rate of anomalies fixed in the alternative software source code; 10. A computer program product according to claim 9.

15. 1. A computer system for identifying uses of deprecated software source code in a software repository, the computer system comprising: one or more computer processors; one or more computer-readable storage media; and program instructions stored on the one or more computer-readable storage media for execution by at least one of the one or more computer processors, the program instructions comprising: program instructions for analyzing one or more software repositories for software source code identified as deprecated by the machine learning model; program instructions for, in response to identifying the deprecated software source code, alerting a first one or more software developers responsible for maintaining software source code modules using the deprecated software source code; program instructions for recommending to the first one or more software developers alternative software source code for use in the software source code module to replace the deprecated software source code; and program instructions for recommending a testing procedure for the alternative software source code. Computer system.

16. further comprising program instructions for highlighting the deprecated software source code.

16. The computer system of claim 15.

17. the warning further includes notifying a second one or more software developers responsible for supporting the deprecated software source code of the identity of the first one or more software developers using the deprecated software source code; 16. The computer system of claim 15.

18. the warning further includes providing information to the first one or more software developers including why the deprecated software source code is no longer supported and when the deprecated software source code is no longer supported.

16. The computer system of claim 15.

19. the replacement software source code is determined based on machine learning of multiple repositories or is selected by a second one or more software developers responsible for supporting the deprecated software source code; 16. The computer system of claim 15.

20. the testing procedure is recommended based on data related to the alternative software source code, including the length of time the alternative software source code has been available, the number of installed uses of the alternative software source code, a quality rating of the alternative software source code, the number of anomalies fixed in the alternative software source code, and a trend in the rate of anomalies fixed in the alternative software source code; 17. The computer system of claim 16.

Images